| /*!**************************************************************************** |
| |
| @file PVRTGlobal.h |
| @copyright Copyright (c) Imagination Technologies Limited. |
| @brief Global defines and typedefs for PVRTools |
| |
| ******************************************************************************/ |
| #ifndef _PVRTGLOBAL_H_ |
| #define _PVRTGLOBAL_H_ |
| |
| /*!*************************************************************************** |
| Macros |
| *****************************************************************************/ |
| #define PVRT_MIN(a,b) (((a) < (b)) ? (a) : (b)) |
| #define PVRT_MAX(a,b) (((a) > (b)) ? (a) : (b)) |
| #define PVRT_CLAMP(x, l, h) (PVRT_MIN((h), PVRT_MAX((x), (l)))) |
| |
| // avoid warning about unused parameter |
| #define PVRT_UNREFERENCED_PARAMETER(x) ((void) x) |
| |
| #if defined(_WIN32) && !defined(__QT__) && !defined(UNDER_CE) /* Windows desktop */ |
| #if !defined(_CRTDBG_MAP_ALLOC) |
| #define _CRTDBG_MAP_ALLOC |
| #endif |
| #include <windows.h> |
| #include <crtdbg.h> |
| #include <tchar.h> |
| #endif |
| |
| #if defined(UNDER_CE) |
| #include <windows.h> |
| |
| #ifndef _ASSERT |
| #ifdef _DEBUG |
| #define _ASSERT(X) { (X) ? 0 : DebugBreak(); } |
| #else |
| #define _ASSERT(X) |
| #endif |
| #endif |
| |
| #ifndef _ASSERTE |
| #ifdef _DEBUG |
| #define _ASSERTE _ASSERT |
| #else |
| #define _ASSERTE(X) |
| #endif |
| #endif |
| #define _RPT0(a,b) |
| #define _RPT1(a,b,c) |
| #define _RPT2(a,b,c,d) |
| #define _RPT3(a,b,c,d,e) |
| #define _RPT4(a,b,c,d,e,f) |
| #else |
| |
| #if defined(_WIN32) && !defined(__QT__) |
| |
| #else |
| #if defined(__linux__) || defined(__APPLE__) |
| #include <assert.h> |
| #ifdef _DEBUG |
| #ifndef _RPT0 |
| #define _RPT0(a,b) printf(b) |
| #endif |
| #ifndef _RPT1 |
| #define _RPT1(a,b,c) printf(b,c) |
| #endif |
| #ifndef _ASSERT |
| #define _ASSERT(a) assert(a) |
| #endif |
| #ifndef _ASSERTE |
| #define _ASSERTE(a) assert(a) |
| #endif |
| #else |
| #ifndef _RPT0 |
| #define _RPT0(a,b)((void)0) |
| #endif |
| #ifndef _RPT1 |
| #define _RPT1(a,b,c)((void)0) |
| #endif |
| #ifndef _ASSERT |
| #define _ASSERT(a)((void)0) |
| #endif |
| #ifndef _ASSERTE |
| #define _ASSERTE(a)((void)0) |
| #endif |
| #endif |
| #ifndef _RPT2 |
| #define _RPT2(a,b,c,d)((void)0) |
| #endif |
| #ifndef _RPT3 |
| #define _RPT3(a,b,c,d,e)((void)0) |
| #endif |
| #ifndef _RPT4 |
| #define _RPT4(a,b,c,d,e,f)((void)0) |
| #endif |
| #include <stdlib.h> |
| #include <string.h> |
| #ifndef BYTE |
| #define BYTE unsigned char |
| #endif |
| #ifndef WORD |
| #define WORD unsigned short |
| #endif |
| #ifndef DWORD |
| #define DWORD unsigned int |
| #endif |
| #if !defined(BOOL) && !defined(OBJC_BOOL_DEFINED) |
| #define BOOL int |
| #endif |
| typedef struct tagRGBQUAD { |
| BYTE rgbBlue; |
| BYTE rgbGreen; |
| BYTE rgbRed; |
| BYTE rgbReserved; |
| } RGBQUAD; |
| #if !defined(TRUE) |
| #define TRUE 1 |
| #endif |
| #if !defined(FALSE) |
| #define FALSE 0 |
| #endif |
| #else |
| #define _CRT_WARN 0 |
| #define _RPT0(a,b) |
| #define _RPT1(a,b,c) |
| #define _RPT2(a,b,c,d) |
| #define _RPT3(a,b,c,d,e) |
| #define _RPT4(a,b,c,d,e,f) |
| #define _ASSERT(X) |
| #define _ASSERTE(X) |
| #endif |
| #endif |
| #endif |
| |
| #include <stdio.h> |
| |
| #define FREE(X) { if(X) { free(X); (X) = 0; } } |
| |
| // This macro is used to check at compile time that types are of a certain size |
| // If the size does not equal the expected size, this typedefs an array of size 0 |
| // which causes a compile error |
| #define PVRTSIZEASSERT(T, size) typedef int (sizeof_##T)[sizeof(T) == (size)] |
| #define PVRTCOMPILEASSERT(T, expr) typedef int (assert_##T)[expr] |
| |
| |
| /**************************************************************************** |
| ** Integer types |
| ****************************************************************************/ |
| |
| typedef char PVRTchar8; |
| typedef signed char PVRTint8; |
| typedef signed short PVRTint16; |
| typedef signed int PVRTint32; |
| typedef unsigned char PVRTuint8; |
| typedef unsigned short PVRTuint16; |
| typedef unsigned int PVRTuint32; |
| |
| typedef float PVRTfloat32; |
| |
| #if (defined(__int64) || defined(_WIN32)) |
| typedef signed __int64 PVRTint64; |
| typedef unsigned __int64 PVRTuint64; |
| #elif defined(__GNUC__) |
| __extension__ typedef signed long long PVRTint64; |
| __extension__ typedef unsigned long long PVRTuint64; |
| #else |
| typedef signed long long PVRTint64; |
| typedef unsigned long long PVRTuint64; |
| #endif |
| |
| #if __SIZEOF_WCHAR_T__ == 4 || __WCHAR_MAX__ > 0x10000 |
| #define PVRTSIZEOFWCHAR 4 |
| #else |
| #define PVRTSIZEOFWCHAR 2 |
| #endif |
| |
| PVRTSIZEASSERT(PVRTchar8, 1); |
| PVRTSIZEASSERT(PVRTint8, 1); |
| PVRTSIZEASSERT(PVRTuint8, 1); |
| PVRTSIZEASSERT(PVRTint16, 2); |
| PVRTSIZEASSERT(PVRTuint16, 2); |
| PVRTSIZEASSERT(PVRTint32, 4); |
| PVRTSIZEASSERT(PVRTuint32, 4); |
| PVRTSIZEASSERT(PVRTint64, 8); |
| PVRTSIZEASSERT(PVRTuint64, 8); |
| PVRTSIZEASSERT(PVRTfloat32, 4); |
| |
| /*!************************************************************************** |
| @enum ETextureFilter |
| @brief Enum values for defining texture filtering |
| ****************************************************************************/ |
| enum ETextureFilter |
| { |
| eFilter_Nearest, |
| eFilter_Linear, |
| eFilter_None, |
| |
| eFilter_Size, |
| eFilter_Default = eFilter_Linear, |
| eFilter_MipDefault = eFilter_None |
| }; |
| |
| /*!************************************************************************** |
| @enum ETextureWrap |
| @brief Enum values for defining texture wrapping |
| ****************************************************************************/ |
| enum ETextureWrap |
| { |
| eWrap_Clamp, |
| eWrap_Repeat, |
| |
| eWrap_Size, |
| eWrap_Default = eWrap_Repeat |
| }; |
| |
| /**************************************************************************** |
| ** swap template function |
| ****************************************************************************/ |
| /*!*************************************************************************** |
| @brief A swap template function that swaps a and b |
| @param[in] a Type a |
| @param[in] b Type b |
| *****************************************************************************/ |
| |
| template <typename T> |
| inline void PVRTswap(T& a, T& b) |
| { |
| T temp = a; |
| a = b; |
| b = temp; |
| } |
| |
| /*!*************************************************************************** |
| @brief A clamp template function that clamps val between min and max. |
| @param[in] val Value to clamp |
| @param[in] min Minimum legal value |
| @param[in] max Maximum legal value |
| *****************************************************************************/ |
| template <typename T> |
| inline T PVRTClamp(const T& val, const T& min, const T& max) |
| { |
| if(val > max) |
| return max; |
| if(val < min) |
| return min; |
| return val; |
| } |
| |
| /*!*************************************************************************** |
| @brief Swaps the endianness of pBytes in place |
| @param[in] pBytes A number |
| @param[in] i32ByteNo Number of bytes in pBytes |
| *****************************************************************************/ |
| inline void PVRTByteSwap(unsigned char* pBytes, int i32ByteNo) |
| { |
| int i = 0, j = i32ByteNo - 1; |
| |
| while(i < j) |
| PVRTswap<unsigned char>(pBytes[i++], pBytes[j--]); |
| } |
| |
| /*!*************************************************************************** |
| @brief Converts the endianness of an unsigned int |
| @param[in] ui32Long A number |
| @return ui32Long with its endianness changed |
| *****************************************************************************/ |
| inline unsigned int PVRTByteSwap32(unsigned int ui32Long) |
| { |
| return ((ui32Long&0x000000FF)<<24) + ((ui32Long&0x0000FF00)<<8) + ((ui32Long&0x00FF0000)>>8) + ((ui32Long&0xFF000000) >> 24); |
| } |
| |
| /*!*************************************************************************** |
| @brief Converts the endianness of a unsigned short |
| @param[in] ui16Short A number |
| @return ui16Short with its endianness changed |
| *****************************************************************************/ |
| inline unsigned short PVRTByteSwap16(unsigned short ui16Short) |
| { |
| return (ui16Short>>8) | (ui16Short<<8); |
| } |
| |
| /*!*************************************************************************** |
| @brief Returns true if the platform the code is ran on is little endian |
| @return True if the platform the code is ran on is little endian |
| *****************************************************************************/ |
| inline bool PVRTIsLittleEndian() |
| { |
| static bool bLittleEndian; |
| static bool bIsInit = false; |
| |
| if(!bIsInit) |
| { |
| short int word = 0x0001; |
| char *byte = (char*) &word; |
| bLittleEndian = byte[0] ? true : false; |
| bIsInit = true; |
| } |
| |
| return bLittleEndian; |
| } |
| |
| #endif // _PVRTGLOBAL_H_ |
| |
| /***************************************************************************** |
| End of file (Tools.h) |
| *****************************************************************************/ |
| |
