635 lines
18 KiB
C++
635 lines
18 KiB
C++
#ifndef HGL_TYPE_FUNC_INCLUDE
|
|
#define HGL_TYPE_FUNC_INCLUDE
|
|
|
|
#include<hgl/platform/Platform.h>
|
|
#include<math.h>
|
|
namespace hgl
|
|
{
|
|
#define HGL_CONVER_TO_MEM_ALIGN(x) ((((x)+HGL_MEM_ALIGN-1)/HGL_MEM_ALIGN)*HGL_MEM_ALIGN) //内存对齐转换宏
|
|
|
|
#ifndef NULL
|
|
#define NULL 0
|
|
#endif//
|
|
|
|
template<typename T>
|
|
inline T *zero_new(const int count)
|
|
{
|
|
T *result=new T[count];
|
|
|
|
if(!result)
|
|
return(nullptr);
|
|
|
|
memset(result,0,count*sizeof(T));
|
|
return result;
|
|
}
|
|
|
|
template<typename T>
|
|
inline T *zero_malloc(const int count)
|
|
{
|
|
T *result=hgl_malloc(count*sizeof(T));
|
|
|
|
if(!result)
|
|
return(nullptr);
|
|
|
|
memset(result,0,count*sizeof(T));
|
|
return result;
|
|
}
|
|
|
|
template<typename T>
|
|
inline void hgl_call_construct(T *obj) //呼叫构造函数
|
|
{
|
|
new (static_cast<void *>(obj)) T();
|
|
}
|
|
|
|
#define HGL_BIT(n) (1<<(n))
|
|
#define HGL_64BIT(n) (1L<<(n))
|
|
|
|
template<typename T>
|
|
inline bool hgl_is_one(const T value,int off)
|
|
{
|
|
return value&(1<<off);
|
|
}
|
|
|
|
template<typename T>
|
|
inline bool hgl_is_zero(const T value,int off)
|
|
{
|
|
return !(value&(1<<off));
|
|
}
|
|
|
|
template<typename T>
|
|
inline void hgl_set_one(T &value,int off)
|
|
{
|
|
value|=(1<<off);
|
|
}
|
|
|
|
template<typename T>
|
|
inline void hgl_set_zero(T &value,int off)
|
|
{
|
|
value&=~T(1<<off);
|
|
}
|
|
|
|
template<typename T>
|
|
inline void hgl_set_bit(T &value,int off,bool b)
|
|
{
|
|
if(b)
|
|
hgl_set_one(value,off);
|
|
else
|
|
hgl_set_zero(value,off);
|
|
}
|
|
|
|
template<typename T>
|
|
inline int hgl_bit_count(const T value)
|
|
{
|
|
int count=0;
|
|
T bit=1;
|
|
|
|
for(int i=0;i<sizeof(T);i++)
|
|
{
|
|
if(value&bit)
|
|
++count;
|
|
|
|
bit<<=1;
|
|
}
|
|
|
|
return count;
|
|
}
|
|
|
|
template<typename T>
|
|
inline int hgl_bit_count(const T value,int size)
|
|
{
|
|
int count=0;
|
|
T bit=1;
|
|
|
|
for(int i=0;i<size;i++)
|
|
{
|
|
if(value&bit)
|
|
++count;
|
|
|
|
bit<<=1;
|
|
}
|
|
|
|
return count;
|
|
}
|
|
|
|
#define DEF_RGB_U8_TO_F(r,g,b) {float(r)/255.0f,float(g)/255.0f,float(b)/255.0f}
|
|
#define DEF_RGBA_U8_TO_F(r,g,b,a) {float(r)/255.0f,float(g)/255.0f,float(b)/255.0f,float(a)/255.0f}
|
|
|
|
constexpr uint HGL_SIZE_1KB =1024;
|
|
constexpr uint HGL_SIZE_1MB =HGL_SIZE_1KB*1024;
|
|
constexpr uint HGL_SIZE_1GB =HGL_SIZE_1MB*1024;
|
|
constexpr uint64 HGL_SIZE_1TB =HGL_SIZE_1GB*1024ULL;
|
|
constexpr uint64 HGL_SIZE_1PB =HGL_SIZE_1TB*1024ULL;
|
|
constexpr uint64 HGL_SIZE_1EB =HGL_SIZE_1PB*1024ULL;
|
|
// constexpr uint128 HGL_SIZE_1ZB =HGL_SIZE_1EB*1024ULL;
|
|
// constexpr uint128 HGL_SIZE_1YB =HGL_SIZE_1ZB*1024ULL;
|
|
|
|
constexpr uint8 HGL_U8_MAX =0xFF;
|
|
constexpr uint16 HGL_U16_MAX =0xFFFF;
|
|
constexpr uint32 HGL_U32_MAX =0xFFFFFFFF;
|
|
constexpr uint64 HGL_U64_MAX =0xFFFFFFFFFFFFFFFFULL;
|
|
|
|
constexpr int8 HGL_S8_MAX =0x7F;
|
|
constexpr int16 HGL_S16_MAX =0x7FFF;
|
|
constexpr int32 HGL_S32_MAX =0x7FFFFFFF;
|
|
constexpr int64 HGL_S64_MAX =0x7FFFFFFFFFFFFFFFLL;
|
|
|
|
constexpr int8 HGL_S8_MIN =(-0x80);
|
|
constexpr int16 HGL_S16_MIN =(-0x8000);
|
|
|
|
#ifdef _MSC_VER
|
|
constexpr int32 HGL_S32_MIN =(-0x80000000i32);
|
|
constexpr int64 HGL_S64_MIN =(-0x8000000000000000i64);
|
|
#else
|
|
constexpr int32 HGL_S32_MIN =(-0x80000000L);
|
|
constexpr int64 HGL_S64_MIN =(-0x8000000000000000LL);
|
|
#endif//_MSC_VER
|
|
|
|
template<typename T> T HGL_INTEGER_MAX();
|
|
template<typename T> T HGL_INTEGER_MIN();
|
|
|
|
template<> inline uint8 HGL_INTEGER_MAX<uint8 >() { return HGL_U8_MAX; }
|
|
template<> inline uint16 HGL_INTEGER_MAX<uint16 >() { return HGL_U16_MAX; }
|
|
template<> inline uint32 HGL_INTEGER_MAX<uint32 >() { return HGL_U32_MAX; }
|
|
template<> inline uint64 HGL_INTEGER_MAX<uint64 >() { return HGL_U64_MAX; }
|
|
|
|
template<> inline int8 HGL_INTEGER_MAX<int8 >() { return HGL_S8_MAX; }
|
|
template<> inline int16 HGL_INTEGER_MAX<int16 >() { return HGL_S16_MAX; }
|
|
template<> inline int32 HGL_INTEGER_MAX<int32 >() { return HGL_S32_MAX; }
|
|
template<> inline int64 HGL_INTEGER_MAX<int64 >() { return HGL_S64_MAX; }
|
|
|
|
template<> inline int8 HGL_INTEGER_MIN<int8 >() { return HGL_S8_MIN; }
|
|
template<> inline int16 HGL_INTEGER_MIN<int16 >() { return HGL_S16_MIN; }
|
|
template<> inline int32 HGL_INTEGER_MIN<int32 >() { return HGL_S32_MIN; }
|
|
template<> inline int64 HGL_INTEGER_MIN<int64 >() { return HGL_S64_MIN; }
|
|
|
|
/**
|
|
* 星期每天枚举
|
|
*/
|
|
enum WeekDay
|
|
{
|
|
weekNone=-1,
|
|
|
|
weekSunday, ///<星期天
|
|
weekMonday, ///<星期一
|
|
weekTuesday, ///<星期二
|
|
weekWednesday, ///<星期三
|
|
weekThursday, ///<星期四
|
|
weekFriday, ///<星期五
|
|
weekSaturday, ///<星期六
|
|
|
|
weekEnd
|
|
};
|
|
|
|
/**
|
|
* 月份枚举
|
|
*/
|
|
enum Month
|
|
{
|
|
monthNone=0,
|
|
|
|
monthJanuary, ///<一月
|
|
monthFebruary, ///<二月
|
|
monthMarch, ///<三月
|
|
monthApril, ///<四月
|
|
monthMay, ///<五月
|
|
monthJune, ///<六月
|
|
monthJuly, ///<七月
|
|
monthAugust, ///<八月
|
|
monthSeptember, ///<九月
|
|
monthOctober, ///<十月
|
|
monthNovember, ///<十一月
|
|
monthDecember, ///<十二月
|
|
|
|
monthEnd
|
|
};
|
|
|
|
constexpr uint HGL_TIME_ONE_SECOND =1;
|
|
constexpr uint HGL_TIME_HALF_MINUTE =30;
|
|
constexpr uint HGL_TIME_ONE_MINUTE =60;
|
|
constexpr uint HGL_TIME_HALF_HOUR =30*HGL_TIME_ONE_MINUTE;
|
|
constexpr uint HGL_TIME_ONE_HOUR =60*HGL_TIME_ONE_MINUTE;
|
|
constexpr uint HGL_TIME_HALF_DAY =12*HGL_TIME_ONE_HOUR;
|
|
constexpr uint HGL_TIME_ONE_DAY =24*HGL_TIME_ONE_HOUR;
|
|
constexpr uint HGL_TIME_ONE_WEEK =7*HGL_TIME_ONE_DAY;
|
|
constexpr uint HGL_TIME_ONE_YEAR =365*HGL_TIME_ONE_DAY;
|
|
|
|
constexpr uint HGL_HOUR_HALF_DAY =12;
|
|
constexpr uint HGL_HOUR_ONE_DAY =24;
|
|
|
|
constexpr uint HGL_DAY_ONE_WEEK =7;
|
|
constexpr uint HGL_DAY_ONE_YEAR =365;
|
|
|
|
constexpr uint HGL_MONTH_ONE_YEAR =12;
|
|
|
|
constexpr uint HGL_MILLI_SEC_PRE_SEC =1000; //毫秒
|
|
constexpr uint HGL_MICRO_SEC_PER_SEC =1000*1000; //微秒
|
|
constexpr uint HGL_NANO_SEC_PER_SEC =1000*1000*1000; //纳秒
|
|
|
|
constexpr char LowerHexChar[16]={'0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f'}; ///<小写16进制字符
|
|
constexpr char UpperHexChar[16]={'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'}; ///<大写16进制字符
|
|
|
|
constexpr double HGL_E =2.7182818284590452353602874713526624977572470936999595749669676277240766303535475945713821785251664274; //欧拉数(自然对数的底数)
|
|
constexpr double HGL_LOG2E =1.44269504088896340736;
|
|
constexpr double HGL_LOG10E =0.434294481903251827651;
|
|
constexpr double HGL_LN2 =0.693147180559945309417;
|
|
constexpr double HGL_LN10 =2.30258509299404568402;
|
|
constexpr double HGL_PI =3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342117068;
|
|
constexpr double HGL_PI_2 =1.57079632679489661923;
|
|
constexpr double HGL_PI_4 =0.785398163397448309616;
|
|
constexpr double HGL_PI_3_4 =2.356194490192344928938;
|
|
constexpr double HGL_1_PI =0.318309886183790671538;
|
|
constexpr double HGL_2_PI =0.636619772367581343076;
|
|
constexpr double HGL_2_SQRTPI =1.12837916709551257390;
|
|
constexpr double HGL_SQRT2 =1.41421356237309504880168872420969807;
|
|
constexpr double HGL_SQRT1_2 =0.707106781186547524401;
|
|
|
|
constexpr double HGL_COS_ANG_0 =1;
|
|
constexpr double HGL_COS_ANG_45 =0.707106781187;
|
|
constexpr double HGL_COS_ANG_90 =0;
|
|
constexpr double HGL_COS_ANG_135=-0.707106781187;
|
|
constexpr double HGL_COS_ANG_180=-1;
|
|
constexpr double HGL_COS_ANG_225=-0.707106781187;
|
|
constexpr double HGL_COS_ANG_270=0;
|
|
constexpr double HGL_COS_ANG_315=0.707106781187;
|
|
|
|
constexpr double HGL_GOLDEN_RATIO =0.61803398874989484820458683436563811772030917980576;//黄金比例
|
|
constexpr double HGL_SILVER_RATIO =2.4142135623730950488; //白银比例
|
|
|
|
constexpr double HGL_SPEED_OF_SOUND =331.3f; //音速(米/秒)
|
|
constexpr double HGL_SPEED_OF_LIGHT =299792458; //光速(米/秒)
|
|
|
|
constexpr double HGL_ABSOLUTE_ZERO =-273.15f; //绝对零度
|
|
|
|
constexpr double HGL_UNIVERSAL_GRAVITATION =6.67384e-11; //万有引力常数
|
|
|
|
constexpr double HGL_EARTH_GRAVITATIONAL_ACCELERATION =9.80665; //地球上的重力加速度(牛顿)
|
|
constexpr double HGL_EARTH_MASS =5.9722e+24; //地球质量
|
|
constexpr double HGL_EARTH_RADIUS =6371000; //地球半径(米)
|
|
|
|
/**
|
|
* 物体万有引力计算
|
|
* @param m1 星球质量
|
|
* @param m2 物体质量
|
|
* @param length 到星球中心的距离
|
|
*/
|
|
template<typename T>
|
|
inline T UniversalGravitation(const T m1,const T m2,const T length)
|
|
{
|
|
return HGL_UNIVERSAL_GRAVITATION*((m1*m2)/(length*length));
|
|
}
|
|
|
|
/**
|
|
* 星球重力加速度计算<br>
|
|
* 理论上: (地球质量*万有引力常数)/(地球半径的平方)=地球上的重力加速度
|
|
* @param m 星球质量
|
|
* @param raidus 星球半径
|
|
* @return 星球的重力加速度(牛顿)
|
|
*/
|
|
template<typename T>
|
|
inline T UniversalGravitation(const T m,const T radius)
|
|
{
|
|
return (HGL_UNIVERSAL_GRAVITATION*m)/(radius*radius);
|
|
}
|
|
|
|
/**
|
|
* 向心力计算
|
|
* @param m 质量
|
|
* @param v 速度
|
|
* @param r 距离
|
|
*/
|
|
template<typename T>
|
|
inline T CentripetalForce(const T m,const T v,const T r)
|
|
{
|
|
return (m*v*v)/r;
|
|
}
|
|
|
|
/**
|
|
* 加速度计算
|
|
* @param power 推力
|
|
* @param weight 质量
|
|
*/
|
|
template<typename T>
|
|
inline T AddSpeed(const T &power,const T &weight)
|
|
{
|
|
return power/weight;
|
|
}
|
|
|
|
/**
|
|
* 物体运动质量计算(物体运动越快，质量越大)
|
|
* @param m0 静止质量
|
|
* @param v 运动速度
|
|
*/
|
|
template<typename T>
|
|
inline T RunWeight(const T &m0,const T &v)
|
|
{
|
|
return m0/sqrt(1-(v*v)/(HGL_SPEED_OF_LIGHT*HGL_SPEED_OF_LIGHT));
|
|
}
|
|
|
|
inline float half_to_float(const uint16 &h)
|
|
{
|
|
return ((h&0x8000)<<16) | (((h&0x7c00)+0x1C000)<<13) | ((h&0x03FF)<<13);
|
|
}
|
|
|
|
inline uint16 float_to_half(const float &f)
|
|
{
|
|
const uint32 x = *((uint32 *)&f);
|
|
|
|
return ((x>>16)&0x8000)|((((x&0x7f800000)-0x38000000)>>13)&0x7c00)|((x>>13)&0x03ff);
|
|
}
|
|
|
|
/**
|
|
* 正圆面积计算
|
|
* @param radius 半径
|
|
*/
|
|
inline double CircleArea(const double radius)
|
|
{
|
|
return(radius*radius*HGL_PI);
|
|
}
|
|
|
|
/**
|
|
* 椭圆面积计算
|
|
* @param l_radius 长半径
|
|
* @param s_radius 短半径
|
|
*/
|
|
inline double ElipseArea(const double l_radius,const double s_radius)
|
|
{
|
|
return(l_radius*s_radius*HGL_PI);
|
|
}
|
|
|
|
/**
|
|
* 球体积计算
|
|
* @param radius 球半径
|
|
*/
|
|
inline double SphereVolume(const double radius)
|
|
{
|
|
return(radius*radius*radius*(HGL_PI*4.0f))/3.0f;
|
|
}
|
|
|
|
/**
|
|
* 椭球体积计算
|
|
* @param x_radius x半径
|
|
* @param y_radius y半径
|
|
* @param z_radius z半径
|
|
*/
|
|
inline double EllipsoidVolume(const double x_radius,const double y_radius,const double z_radius)
|
|
{
|
|
return(x_radius*y_radius*z_radius*(HGL_PI*4.0f))/3.0f;
|
|
}
|
|
|
|
/**
|
|
* 取适合正巧大于当前数的2次幂值
|
|
*/
|
|
template<typename T>
|
|
inline T power_to_2(T value)
|
|
{
|
|
T result=1;
|
|
|
|
while(result<value)
|
|
result<<=1;
|
|
|
|
return(result);
|
|
}
|
|
|
|
template<typename T> inline void hgl_swap(T &x,T &y)
|
|
{
|
|
T t;
|
|
|
|
memcpy(&t,&x,sizeof(T));
|
|
memcpy(&x,&y,sizeof(T));
|
|
memcpy(&y,&t,sizeof(T));
|
|
}
|
|
|
|
template<typename T> inline T hgl_abs(const T &v){return (v>=0?v:-v);}
|
|
|
|
template<typename T> inline T hgl_min(const T &a,const T &b){return (a>b?b:a);}
|
|
template<typename T> inline T hgl_max(const T &a,const T &b){return (a>b?a:b);}
|
|
|
|
template<typename T> inline T hgl_min(const T *data,int count,T min_value)
|
|
{
|
|
T value=min_value;
|
|
|
|
for(int i=0;i<count;i++)
|
|
{
|
|
if(*data<value)
|
|
value=*data;
|
|
|
|
++data;
|
|
}
|
|
|
|
return(value);
|
|
}
|
|
|
|
template<typename T> inline T hgl_max(const T *data,int count,T max_value)
|
|
{
|
|
T value=max_value;
|
|
|
|
for(int i=0;i<count;i++)
|
|
{
|
|
if(*data>value)
|
|
value=*data;
|
|
|
|
++data;
|
|
}
|
|
|
|
return(value);
|
|
}
|
|
|
|
/**
|
|
* 角度转弧度
|
|
*/
|
|
inline double hgl_ang2rad(const double ang)
|
|
{
|
|
return ang*(HGL_PI/180.0f);
|
|
}
|
|
|
|
/**
|
|
* 弧度转角度
|
|
*/
|
|
inline double hgl_rad2ang(const double rad)
|
|
{
|
|
return rad*(180.0f/HGL_PI);
|
|
}
|
|
|
|
/**
|
|
* 浮点数截取小数点后指定位度
|
|
* @param value 要截取的浮点数
|
|
* @param num 要截取的位数
|
|
*/
|
|
template<typename T>
|
|
inline T hgl_clip_float(const T value,const int num)
|
|
{
|
|
if(num<=0)
|
|
return int64(value);
|
|
|
|
if(value==0)return(0);
|
|
|
|
double per=pow(10,num);
|
|
|
|
return double(floor(value*per))/per;
|
|
}
|
|
|
|
/**
|
|
* 等值类型复制
|
|
*/
|
|
template<typename T>
|
|
inline void hgl_cpy(T &dst,const T &src)
|
|
{
|
|
memcpy(&dst,&src,sizeof(T));
|
|
}
|
|
|
|
/**
|
|
* 不同类型数据块复制
|
|
*/
|
|
template<typename S,typename D>
|
|
inline void hgl_cpy(D *dst,const S *src,const size_t count)
|
|
{
|
|
for(size_t i=0;i<count;i++)
|
|
{
|
|
*dst=D(*src);
|
|
++dst;
|
|
++src;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 同类型数据块复制
|
|
*/
|
|
template<typename T>
|
|
inline void hgl_typecpy(T *dst,const T *src,const size_t count)
|
|
{
|
|
memcpy(dst,src,count*sizeof(T));
|
|
}
|
|
|
|
/**
|
|
* 同类型数据块移动
|
|
*/
|
|
template<typename T>
|
|
inline void hgl_typemove(T *dst,const T *src,const size_t count)
|
|
{
|
|
memmove(dst,src,count*sizeof(T));
|
|
}
|
|
|
|
/**
|
|
* 指定类型数据块赋值
|
|
*/
|
|
template<typename T>
|
|
inline void hgl_set(T *data,const T value,const size_t count)
|
|
{
|
|
for(size_t i=0;i<count;i++)
|
|
{
|
|
*data=value;
|
|
++data;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 指定类型数据块清0
|
|
*/
|
|
template<typename T>
|
|
inline void hgl_zero(T *data,const size_t count)
|
|
{
|
|
memset(data,0,count*sizeof(T));
|
|
}
|
|
|
|
/**
|
|
* 分配指定类型数据块并清0
|
|
*/
|
|
template<typename T>
|
|
inline T *hgl_zero_new(const size_t count)
|
|
{
|
|
if(count<=0)return(nullptr);
|
|
|
|
T *data=new T[count];
|
|
memset(data,0,count*sizeof(T));
|
|
return data;
|
|
}
|
|
|
|
template<typename T>
|
|
inline T *hgl_copy_new(const size_t count,const T *src)
|
|
{
|
|
if(count<=0)return(nullptr);
|
|
|
|
T *data=new T[count];
|
|
memcpy(data,src,count*sizeof(T));
|
|
return data;
|
|
}
|
|
|
|
/**
|
|
* 指定类型数据清0
|
|
*/
|
|
template<typename T>
|
|
inline void hgl_zero(T &data)
|
|
{
|
|
memset(&data,0,sizeof(T));
|
|
}
|
|
}//namespace hgl
|
|
|
|
/**
|
|
* 比较处理模板基类
|
|
*/
|
|
template<typename T> class Comparator ///比较处理模板基类
|
|
{
|
|
public:
|
|
|
|
/**
|
|
* 比较函数，需被特例化或派生实现
|
|
*/
|
|
virtual int compare(const T &a,const T &b)const
|
|
{
|
|
return 0; // 如 return(a-b); ，但这个函数正确情况下不应该会被调用
|
|
}
|
|
|
|
/**
|
|
* 交换函数
|
|
*/
|
|
virtual void exchange(T &a,T &b)
|
|
{
|
|
T t;
|
|
|
|
memcpy(&t,&a,sizeof(T));
|
|
memcpy(&a,&b,sizeof(T));
|
|
memcpy(&b,&t,sizeof(T));
|
|
}
|
|
|
|
/**
|
|
* 复制数据
|
|
*/
|
|
virtual void cpy(T *t,T *s)
|
|
{
|
|
memcpy(t,s,sizeof(T));
|
|
}
|
|
};//class Comparator
|
|
|
|
//针对原生类型的特例化版本，做适当加速
|
|
#define COMPARATOR_ORIGIN_TYPE(type) template<> class Comparator<type> \
|
|
{ \
|
|
public: \
|
|
int compare(const type &a,const type &b)const{return a-b;} \
|
|
void exchange(type &a,type &b){type t;t=a;a=b;b=t;} \
|
|
void cpy(type *t,type *s){*t=*s;} \
|
|
};
|
|
|
|
COMPARATOR_ORIGIN_TYPE(hgl::int8)
|
|
COMPARATOR_ORIGIN_TYPE(hgl::int16)
|
|
COMPARATOR_ORIGIN_TYPE(hgl::int32)
|
|
COMPARATOR_ORIGIN_TYPE(hgl::int64)
|
|
|
|
COMPARATOR_ORIGIN_TYPE(hgl::uint8)
|
|
COMPARATOR_ORIGIN_TYPE(hgl::uint16)
|
|
COMPARATOR_ORIGIN_TYPE(hgl::uint32)
|
|
COMPARATOR_ORIGIN_TYPE(hgl::uint64)
|
|
|
|
COMPARATOR_ORIGIN_TYPE(float)
|
|
COMPARATOR_ORIGIN_TYPE(double)
|
|
|
|
COMPARATOR_ORIGIN_TYPE(char)
|
|
COMPARATOR_ORIGIN_TYPE(wchar_t)
|
|
|
|
#if HGL_OS != HGL_OS_Windows
|
|
COMPARATOR_ORIGIN_TYPE(u16char)
|
|
#endif//HGL_OS != HGL_OS_Windows
|
|
|
|
COMPARATOR_ORIGIN_TYPE(char32_t)
|
|
#undef COMPARATOR_ORIGIN_TYPE
|
|
#endif//HGL_TYPE_FUNC_INCLUDE
|