diff --git a/example/TextureSampler/main.cpp b/example/TextureSampler/main.cpp index 605a9fab..a8234d1a 100644 --- a/example/TextureSampler/main.cpp +++ b/example/TextureSampler/main.cpp @@ -85,8 +85,8 @@ constexpr float vertex_data[]={ -0.75f, 0.75f, constexpr float texcoord_data[]={ -0.25,-0.25, -0.25, 1.25, 1.25,-0.25, - 1.25, 1.25 }; - + 1.25, 1.25 +}; void BindVBO2VAO(const int vao,const int binding_index,const int shader_location,VertexBufferBase *vb) { diff --git a/inc/hgl/LogInfo.h b/inc/hgl/LogInfo.h index 7609e319..3099136e 100644 --- a/inc/hgl/LogInfo.h +++ b/inc/hgl/LogInfo.h @@ -3,6 +3,15 @@ #include #include + +#if (HGL_COMPILER == HGL_COMPILER_GNU)||(HGL_COMPILER == HGL_COMPILER_LLVM) + #define __HGL_FUNC__ __PRETTY_FUNCTION__ +#elif HGL_COMPILER == HGL_COMPILER_Microsoft + #define __HGL_FUNC__ __FUNCSIG__ +#else + #define __HGL_FUNC__ __FUNCTION__ +#endif// + namespace hgl { namespace logger diff --git a/inc/hgl/graph/Texture.h b/inc/hgl/graph/Texture.h new file mode 100644 index 00000000..e858c409 --- /dev/null +++ b/inc/hgl/graph/Texture.h @@ -0,0 +1,53 @@ +#ifndef HGL_GRAPH_TEXTURE_INCLUDE +#define HGL_GRAPH_TEXTURE_INCLUDE + +#include +#include +namespace hgl +{ + namespace graph + { + /** + * 贴图类 + */ + class Texture + { + protected: + + uint type; ///<纹理类型(如GL_TEXTURE_2D类) + + uint texture_id; ///<纹理ID + + uint pixel_format; ///<象素格式(如RED,RG,RGB,RGBA,SRGB,SRGBA之类) + uint video_format; ///<显存格式 + + public: + + Texture(uint t,uint tid) + { + type=t; + texture_id=tid; + + pixel_format=video_format=0; + } + + virtual ~Texture() + { + glDeleteTextures(1,&texture_id); + } + + public: + + uint GetID ()const{return texture_id;} ///<取得纹理ID + uint GetType ()const{return type;} ///<取得类型 + uint GetPixelFormat ()const{return pixel_format;} ///<取得象素格式 + uint GetVideoFormat ()const{return video_format;} ///<取得显存中的数据格式 + + public: + + virtual void GenMipmaps ()=0; ///<生成mipmaps + virtual void GetMipmapLevel (int &base_level,int &max_level)=0; ///<取得贴图mipmaps级别 + };//class Texture + }//namespace graph +}//namespace hgl +#endif//HGL_GRAPH_TEXTURE_INCLUDE diff --git a/inc/hgl/graph/Texture1D.h b/inc/hgl/graph/Texture1D.h new file mode 100644 index 00000000..7844fec9 --- /dev/null +++ b/inc/hgl/graph/Texture1D.h @@ -0,0 +1,68 @@ +#ifndef HGL_GRAPH_TEXTURE_1D_INCLUDE +#define HGL_GRAPH_TEXTURE_1D_INCLUDE + +#include +namespace hgl +{ + namespace graph + { + struct Texture1DData; + + /** + * 1D贴图 + */ + class Texture1D:public Texture + { + protected: + + uint length; + + protected: + + virtual bool _SetImage (Texture1DData *)=0; + virtual int _GetImage (void *data_pointer, TSF fmt, int level)=0; + virtual bool _ChangeImage(uint s, uint l, void *data, uint bytes, TSF sf)=0; + + public: + + uint GetLength ()const{return length;} ///<取得纹理长度 + + public: + + Texture1D(uint tid):Texture(GL_TEXTURE_1D,tid) + { + length=0; + } + + bool SetImage (Texture1DData *); ///<创建1D贴图数据 + bool SetImage (uint l, TSF fmt) ///<创建1D贴图数据 + { + Texture1DData tex(l,fmt); + + return SetImage(&tex); + } + + bool SetImage (uint l, void *data, uint size, TSF sf, uint vf) + { + Texture1DData tex(l, data, size, sf, vf); + + return SetImage(&tex); + } + + bool ChangeImage (uint s,uint l,void *data,uint size,TSF sf); ///<更改1D贴图数据 + + int GetImage (void *data_pointer,TSF fmt,int level=0); ///<取得1D贴图数据 + + public: + + virtual void GenMipmaps ()=0; ///<生成mipmaps + virtual void GetMipmapLevel (int &base_level,int &max_level)=0; ///<取得贴图mipmaps级别 + };//class Texture1D + + Texture1D *CreateTexture1D(); + Texture1D *CreateTexture1D(Texture1DData *); + Texture1D *CreateTexture1D(uint length,TSF format); + Texture1D *CreateTexture1D(uint length,void *bitmap,uint bitmap_bytes,TSF source_format,uint video_format); + }//namespace graph +}//namespace hgl +#endif//HGL_GRAPH_TEXTURE_1D_INCLUDE diff --git a/inc/hgl/graph/Texture2D.h b/inc/hgl/graph/Texture2D.h new file mode 100644 index 00000000..b426ae75 --- /dev/null +++ b/inc/hgl/graph/Texture2D.h @@ -0,0 +1,61 @@ +#ifndef HGL_GRAPH_TEXTURE_2D_INCLUDE +#define HGL_GRAPH_TEXTURE_2D_INCLUDE + +#include +namespace hgl +{ + namespace graph + { + /** + * 2D贴图 + */ + class Texture2D:public Texture + { + protected: + + uint width,height; ///<宽、高 + + virtual bool _SetImage (Texture2DData *tex)=0; + virtual int _GetImage (void *data_pointer, TSF fmt, int level,int width,int height)=0; + virtual bool _ChangeImage(uint l, uint t, uint w, uint h, void *data, uint bytes, TSF sf)=0; + + public: + + uint GetWidth ()const{return width;} ///<取得纹理宽度 + uint GetHeight ()const{return height;} ///<取得纹理高度 + + public: + + Texture2D(uint tid):Texture(GL_TEXTURE_2D,tid) + { + width=height=0; + } + + bool SetImage (Texture2DData *); ///<创建2D贴图数据 + bool SetImage (uint w, uint h, TSF fmt) + { + Texture2DData tex(w, h, fmt); + + return SetImage(&tex); + } + bool SetImage (uint w, uint h, void *data, uint size, TSF sf, uint vf) + { + Texture2DData tex(w,h,data,size,sf,vf); + + return SetImage(&tex); + } + + bool ChangeImage (uint l,uint t,uint w,uint h,void *,uint size, TSF sf); ///<更改贴图数据 + + int GetImage (void *data_pointer,TSF fmt,int level=0); ///<取得2D贴图数据 + };//class Texture2D + + Texture2D *CreateTexture2D(); + Texture2D *CreateTexture2D(Texture2DData *); + Texture2D *CreateTexture2D(uint width,uint height,TSF format); + Texture2D *CreateTexture2D(uint width,uint height,void *bitmap,uint bitmap_bytes,TSF source_format,uint video_format); + + Texture2D *CreateTexture2D(const OSString &,uint video_format=0); + }//namespace graph +}//namespace hgl +#endif//HGL_GRAPH_TEXTURE_2D_INCLUDE diff --git a/inc/hgl/graph/TextureData.h b/inc/hgl/graph/TextureData.h new file mode 100644 index 00000000..ba1d7d1f --- /dev/null +++ b/inc/hgl/graph/TextureData.h @@ -0,0 +1,184 @@ +#ifndef HGL_GRAPH_TEXTURE_DATA_INCLUDE +#define HGL_GRAPH_TEXTURE_DATA_INCLUDE + +#include +namespace hgl +{ + namespace graph + { + /** + * 纹理数据 + */ + struct TextureData + { + const TextureFormat * source_format; ///<源始纹理格式 + + uint video_format; ///<显存格式 + + bool gen_mipmaps; ///<是否产生mipmaps + + void * bitmap; ///<位图数据 + + uint bitmap_bytes; ///<位图数据字节数 + + public: + + TextureData()=default; + virtual ~TextureData()=default; + + uint GetVideoFormat()const + { + return(video_format?video_format:source_format->video_format); + } + + uint GetPixelFormat()const + { + return(source_format?source_format->pixel_format:0); + } + + bool SetData(size_t this_size,TSF fmt) + { + if(!TextureSourceFormatCheck(fmt)) + { + hgl_zero(this,this_size); + return(false); + } + + gen_mipmaps=false; + bitmap = nullptr; + bitmap_bytes = 0; + + source_format = TextureFormatInfoList + fmt; //原始数据格式 + video_format = source_format->video_format; //显存格式 + + return(true); + } + + bool SetData(size_t this_size,void *data,uint size,TSF sf,uint vf) + { + if(data&&!TextureSourceFormatCheck(sf)) + { + hgl_zero(this,this_size); + return(false); + } + + gen_mipmaps = false; + bitmap = data; + bitmap_bytes = size; + + source_format = TextureFormatInfoList + sf; //原始数据格式 + video_format = vf ? vf : source_format->video_format; //显存格式 + return(true); + } + };//struct TextureData + + struct Texture1DData:public TextureData + { + uint length; + + public: + + Texture1DData() + { + hgl_zero(this, sizeof(Texture1DData)); + } + + Texture1DData(uint l, TSF fmt) + { + if(!SetData(sizeof(Texture1DData),fmt))return; + + length = l; + } + + Texture1DData(uint l, void *data, uint size, TSF sf, uint vf) + { + if(!SetData(sizeof(Texture1DData),data,size,sf,vf))return; + + length=l; + } + };//struct Texture1DData:public TextureData + + struct Texture2DData:public TextureData + { + uint width, height; + + public: + + Texture2DData() + { + hgl_zero(this, sizeof(Texture2DData)); + } + + Texture2DData(uint w, uint h, TSF fmt) + { + if(!SetData(sizeof(Texture2DData),fmt))return; + + width = w; + height = h; + } + + Texture2DData(uint w,uint h,void *data,uint size,TSF sf,uint vf) + { + if(!SetData(sizeof(Texture2DData),data,size,sf,vf))return; + + width=w; + height=h; + } + };//struct Texture2DData:public TextureData + + using TextureCubeMapData=Texture2DData; //cube map与2d参数一样，只是数据长6倍 + + struct Texture1DArrayData:public TextureData + { + uint length, count; + + public: + + Texture1DArrayData() + { + hgl_zero(this,sizeof(Texture1DArrayData)); + } + + Texture1DArrayData(uint l, uint c, TSF fmt) + { + if(!SetData(sizeof(Texture1DArrayData),fmt))return; + + length=l; + count=c; + } + + Texture1DArrayData(uint l,uint c,void *data,uint size,TSF sf,uint vf) + { + if(!SetData(sizeof(Texture1DArrayData),data,size,sf,vf))return; + + length=l; + count=c; + } + };//struct Texture1DArrayData:public TextureData + + struct Texture2DArrayData:public TextureData + { + uint width, height, count; + + public: + + Texture2DArrayData() + { + hgl_zero(this, sizeof(Texture2DArrayData)); + } + };//struct Texture2DArrayData:public TextureData + + struct Texture3DData:public TextureData + { + uint width, height, depth; + + public: + + Texture3DData() + { + hgl_zero(this, sizeof(Texture3DData)); + } + };//struct Texture3DData:public TextureData + }//namespace graph +}//namespace hgl +#endif//HGL_GRAPH_TEXTURE_DATA_INCLUDE diff --git a/inc/hgl/graph/TextureFormat.h b/inc/hgl/graph/TextureFormat.h new file mode 100644 index 00000000..aad8e764 --- /dev/null +++ b/inc/hgl/graph/TextureFormat.h @@ -0,0 +1,146 @@ +#ifndef HGL_GRAPH_TEXTURE_FORMAT_INCLUDE +#define HGL_GRAPH_TEXTURE_FORMAT_INCLUDE + +#include +#include +namespace hgl +{ + namespace graph + { + //贴图类型,核心模式，肯定支持array/cubemap + #define HGL_TEXTURE_1D GL_TEXTURE_1D + #define HGL_TEXTURE_2D GL_TEXTURE_2D + #define HGL_TEXTURE_3D GL_TEXTURE_3D + #define HGL_TEXTURE_RECTANGLE GL_TEXTURE_RECTANGLE //OpenGL 3.1 + #define HGL_TEXTURE_1D_ARRAY GL_TEXTURE_1D_ARRAY + #define HGL_TEXTURE_2D_ARRAY GL_TEXTURE_2D_ARRAY //OpenGL 3.0 + #define HGL_TEXTURE_CUBE_MAP GL_TEXTURE_CUBE_MAP + #define HGL_TEXTURE_CUBE_MAP_ARRAY GL_TEXTURE_CUBE_MAP_ARRAY //OpenGL 4.0 + #define HGL_TEXTURE_2D_MS GL_TEXTURE_2D_MULTISAMPLE + #define HGL_TEXTURE_2D_MS_ARRAY GL_TEXTURE_2D_MULTISAMPLE_ARRAY //OpenGL 3.2 + + #define HGL_TEXTURE_BUFFER GL_TEXTURE_BUFFER //TBO(OpenGL 3.1) + + // #define HGL_TEX_BIND_1D GL_TEXTURE_BINDING_1D + // #define HGL_TEX_BIND_2D GL_TEXTURE_BINDING_2D + // #define HGL_TEX_BIND_3D GL_TEXTURE_BINDING_3D + // #define HGL_TEX_BIND_RECTANGLE GL_TEXTURE_BINDING_RECTANGLE + // #define HGL_TEX_BIND_1D_ARRAY GL_TEXTURE_BINDING_1D_ARRAY + // #define HGL_TEX_BIND_2D_ARRAY GL_TEXTURE_BINDING_2D_ARRAY + // #define HGL_TEX_BIND_CUBE_MAP GL_TEXTURE_BINDING_CUBE_MAP + // #define HGL_TEX_BIND_CUBE_MAP_ARRAY GL_TEXTURE_BINDING_CUBE_MAP_ARRAY + // #define HGL_TEX_BIND_2D_MS GL_TEXTURE_BINDING_2D_MULTISAMPLE + // #define HGL_TEX_BIND_2D_MS_ARRAY GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY + // #define HGL_TEX_BIND_BUFFER GL_TEXTURE_BINDING_BUFFER + + //采样属性 + + //贴图寻址模式 + #define HGL_WRAP_CLAMP GL_CLAMP_TO_EDGE + #define HGL_WRAP_REPEAT GL_REPEAT + #define HGL_WRAP_MIRRORED_REPEAT GL_MIRRORED_REPEAT + + //贴图过滤模式 + #define HGL_FILTER_NEAREST GL_NEAREST + #define HGL_FILTER_LINEAR GL_LINEAR + #define HGL_FILTER_SMOOTH (GL_LINEAR+1) //(1.此功能为自行实现，使用GL_LINEAR+1只是为了区分。2.OpenGL 4.0以下使用性能较差) + + #define HGL_FILTER_NEAREST_MIPMAP_NEAREST GL_NEAREST_MIPMAP_NEAREST + #define HGL_FILTER_LINEAR_MIPMAP_NEAREST GL_LINEAR_MIPMAP_NEAREST + #define HGL_FILTER_NEAREST_MIPMAP_LINEAR GL_NEAREST_MIPMAP_LINEAR + #define HGL_FILTER_LINEAR_MIPMAP_LINEAR GL_LINEAR_MIPMAP_LINEAR + + //贴图象素格式 + #define HGL_DEPTH16 GL_DEPTH_COMPONENT16 + #define HGL_DEPTH24 GL_DEPTH_COMPONENT24 + #define HGL_DEPTH32 GL_DEPTH_COMPONENT32 + + #define HGL_R8 GL_R8 + #define HGL_R16 GL_R16 + #define HGL_RG8 GL_RG8 + #define HGL_RG16 GL_RG16 + + #define HGL_R3_G3_B2 GL_R3_G3_B2 + #define HGL_RGB4 GL_RGB4 + #define HGL_RGB5 GL_RGB5 + #define HGL_RGB8 GL_RGB8 + #define HGL_RGB10 GL_RGB10 + #define HGL_RGB12 GL_RGB12 + #define HGL_RGB16 GL_RGB16 + #define HGL_RGBA2 GL_RGBA2 + #define HGL_RGBA4 GL_RGBA4 + #define HGL_RGB5_A1 GL_RGB5_A1 + #define HGL_RGBA8 GL_RGBA8 + #define HGL_RGB10_A2 GL_RGB10_A2 + #define HGL_RGBA12 GL_RGBA12 + #define HGL_RGBA16 GL_RGBA16 + #define HGL_SRGB8 GL_SRGB8 + #define HGL_SRGB8_ALPHA8 GL_SRGB8_ALPHA8 + + #define HGL_R16F GL_R16F + #define HGL_RG16F GL_RG16F + #define HGL_RGB16F GL_RGB16F + #define HGL_RGBA16F GL_RGBA16F + + #define HGL_R32F GL_R32F + #define HGL_RG32F GL_RG32F + #define HGL_RGB32F GL_RGB32F + #define HGL_RGBA32F GL_RGBA32F + + #define HGL_RG11F_B10F GL_R11F_G11F_B10F + #define HGL_RGB9_E5 GL_RGB9_E5 + + //压缩贴图格式,核心模式无扩展，所以不用检测 + #define HGL_CR GL_COMPRESSED_RED + #define HGL_CRG GL_COMPRESSED_RG + #define HGL_CRGB GL_COMPRESSED_RGB + #define HGL_CRGBA GL_COMPRESSED_RGBA + + #define HGL_CSRGB GL_COMPRESSED_SRGB + #define HGL_CSRGBA GL_COMPRESSED_SRGB_ALPHA + + #define HGL_DXT1RGB GL_COMPRESSED_RGB_S3TC_DXT1_EXT + #define HGL_DXT1RGBA GL_COMPRESSED_RGBA_S3TC_DXT1_EXT + #define HGL_DXT3RGBA GL_COMPRESSED_RGBA_S3TC_DXT3_EXT + #define HGL_DXT5RGBA GL_COMPRESSED_RGBA_S3TC_DXT5_EXT + #define HGL_LATC1 GL_COMPRESSED_LUMINANCE_LATC1_EXT + #define HGL_LATC1s GL_COMPRESSED_SIGNED_LUMINANCE_LATC1_EXT + #define HGL_LATC2 GL_COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT + #define HGL_LATC2s GL_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2_EXT + #define HGL_RGTC1 GL_COMPRESSED_RED_RGTC1 + #define HGL_RGTC1s GL_COMPRESSED_SIGNED_RED_RGTC1 + #define HGL_RGTC2 GL_COMPRESSED_RG_RGTC2 + #define HGL_RGTC2s GL_COMPRESSED_SIGNED_RG_RGTC2 + #define HGL_BPTC_RGBf GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT_ARB + #define HGL_BPTC_RGBuf GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_ARB + #define HGL_BPTC_RGBA GL_COMPRESSED_RGBA_BPTC_UNORM_ARB + #define HGL_BPTC_SRGBA GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM_ARB + + inline const TextureFormat *GetTextureFormat(const TSF &tsf) + { + if(tsf<=HGL_SF_NONE||tsf>=HGL_SF_END) + return(nullptr); + + return TextureFormatInfoList+tsf; + } + + inline const uint GetVideoFormat(const TSF &tsf) + { + if (tsf <= HGL_SF_NONE || tsf >= HGL_SF_END) + return(0); + + return TextureFormatInfoList[tsf].video_format; + } + + inline const TextureFormat *GetTextureFormat(const char *format) + { + const TextureSourceFormat tsf= GetTextureFormatEnum(format); + + if(tsf<=HGL_SF_NONE||tsf>=HGL_SF_END) + return(nullptr); + + return TextureFormatInfoList+tsf; + } + }//namespace graph +}//namespace hgl +#endif//HGL_GRAPH_TEXTURE_FORMAT_INCLUDE diff --git a/inc/hgl/graph/TextureSourceFormat.h b/inc/hgl/graph/TextureSourceFormat.h new file mode 100644 index 00000000..1f7dd4ba --- /dev/null +++ b/inc/hgl/graph/TextureSourceFormat.h @@ -0,0 +1,140 @@ +#ifndef HGL_GRAPH_TEXTURE_SOURCE_FORMAT_INCLUDE +#define HGL_GRAPH_TEXTURE_SOURCE_FORMAT_INCLUDE + +#include +namespace hgl +{ + namespace graph + { + /** + * 贴图数据源格式 + */ + enum TextureSourceFormat:uint + { + HGL_SF_NONE=0, //无用，做为枚举起始 + + HGL_SF_R8, + HGL_SF_RG8, + HGL_SF_RGB8, + HGL_SF_RGBA8, + + HGL_SF_SRGB8, + HGL_SF_SRGBA8, + + HGL_SF_R16, + HGL_SF_RG16, + HGL_SF_RGB16, + HGL_SF_RGBA16, + + HGL_SF_R16F, + HGL_SF_RG16F, + HGL_SF_RGB16F, + HGL_SF_RGBA16F, + + HGL_SF_R32F, + HGL_SF_RG32F, + HGL_SF_RGB32F, + HGL_SF_RGBA32F, + + HGL_SF_UNCOMPRESSED, //无用，做为非压缩色分隔 + + HGL_SF_R3_G3_B2, + HGL_SF_RGB565, + + HGL_SF_RGBA4, + HGL_SF_RGB5_A1, + HGL_SF_RGB10_A2, + + HGL_SF_RG11F_B10F, + HGL_SF_RGB9_E5, + + HGL_SF_DEPTH, //无用，做为深度分隔 + + HGL_SF_DEPTH16, + HGL_SF_DEPTH24, + HGL_SF_DEPTH32, + + HGL_SF_DEPTH32F, + + HGL_SF_INDEX, //无用，做为索引色分隔 + + HGL_SF_INDEX_16_RGB, + HGL_SF_INDEX_16_RGBA, + HGL_SF_INDEX_256_RGB, + HGL_SF_INDEX_256_RGBA, + + HGL_SF_COMPRESSED, //无用，做为压缩格式分隔 + + //HGL_SF_CR, + //HGL_SF_CRG, + //HGL_SF_CRGB, + //HGL_SF_CRGBA, + + //HGL_SF_CSRGB, + //HGL_SF_CSRGBA, + + HGL_SF_DXT1RGB, + HGL_SF_DXT1RGBA, + HGL_SF_DXT3RGBA, + HGL_SF_DXT5RGBA, + + HGL_SF_LATC1, + HGL_SF_LATC1s, + HGL_SF_LATC2, + HGL_SF_LATC2s, + + HGL_SF_RGTC1, + HGL_SF_RGTC1s, + HGL_SF_RGTC2, + HGL_SF_RGTC2s, + + HGL_SF_BPTC_RGBf, + HGL_SF_BPTC_RGBuf, + HGL_SF_BPTC_RGBA, + HGL_SF_BPTC_SRGBA, + + HGL_SF_ETC2_RGB8, + HGL_SF_ETC2_SRGB8, + HGL_SF_ETC2_RGB8A1, + HGL_SF_ETC2_SRGB8A1, + HGL_SF_ETC2_RGBA8, + HGL_SF_ETC2_SRGBA8, + + HGL_SF_EAC_R11, + HGL_SF_EAC_R11s, + HGL_SF_EAC_RG11, + HGL_SF_EAC_RG11s, + + HGL_SF_END //无用，做为枚举结束 + };//enum TextureSourceFormat + + using TSF=TextureSourceFormat; + + bool TextureSourceFormatCheck(const TextureSourceFormat &); + bool TextureSourceFormatDepthCheck(const TextureSourceFormat &); + + struct TextureFormat + { + TextureSourceFormat tsf; //数据源格式枚举 + + char name[16]; //简写名称 + + bool compress; //是否压缩格式 + uint index; //索引色数量 + + uint video_format; //显存格式 + + uint pixel_format; //象素格式(指R/RG/RGB/RGBA/DEPTH这些) + uint data_type; //数据类型(指BYTE，SHORT，FLOAT这些) + + uint source_bytes; //原始格式字节数 + uint video_bytes; //显存格式字节数 + }; + + //贴图数据源格式信息 + extern const TextureFormat TextureFormatInfoList[HGL_SF_END]; + + TSF GetTextureFormatEnum(const char *); //根据简写名称取得对应的TextureSourceFormat + }//namespace graph +}//namespace hgl +#endif//HGL_GRAPH_TEXTURE_SOURCE_FORMAT_INCLUDE diff --git a/src/RenderDriver/CMakeLists.txt b/src/RenderDriver/CMakeLists.txt index 18784e4a..0ddfb4db 100644 --- a/src/RenderDriver/CMakeLists.txt +++ b/src/RenderDriver/CMakeLists.txt @@ -5,5 +5,10 @@ VertexBuffer.cpp VertexBufferControlDSA.cpp VertexBufferControlBind.cpp - OpenGLDebug.cpp) + OpenGLDebug.cpp + TextureFormat.cpp + Texture1D.cpp + Texture1DDSA.cpp + Texture2D.cpp + Texture2DDSA.cpp) diff --git a/src/RenderDriver/Texture1D.cpp b/src/RenderDriver/Texture1D.cpp new file mode 100644 index 00000000..aabd69b7 --- /dev/null +++ b/src/RenderDriver/Texture1D.cpp @@ -0,0 +1,102 @@ +#include +#include + +namespace hgl +{ + namespace graph + { + bool Texture1D::SetImage(Texture1DData *ptr) + { + if (!ptr) + { + LOG_ERROR(OS_TEXT("param error,ptr=nullptr")); + RETURN_FALSE; + } + + if (!ptr->length) + { + LOG_ERROR(OS_TEXT("size error,image length=") + OSString(ptr->length)); + RETURN_FALSE; + } + + length = ptr->length; + + video_format = ptr->GetVideoFormat(); + pixel_format = ptr->GetPixelFormat(); + + if (!_SetImage(ptr)) + { + length=0; + RETURN_FALSE; + } + + return(true); + } + + int Texture1D::GetImage(void *data_pointer, TSF fmt, int level) + { + if (!TextureSourceFormatCheck(fmt)) + { + LOG_ERROR(OS_TEXT("glTexture1D::GetImage,fmt error =") + OSString(fmt)); + return(-1); + } + + return _GetImage(data_pointer,fmt,level); + } + + bool Texture1D::ChangeImage(uint s, uint l, void *data, uint bytes, TSF sf) + { + if (s >= length + || l>length - s + || !data + || !TextureSourceFormatCheck(sf)) + RETURN_FALSE; + + return _ChangeImage(s,l,data,bytes,sf); + } + }//namespace graph + + namespace graph + { + Texture1D *CreateTexture1DDSA(); + Texture1D *CreateTexture1DBind(); + + Texture1D *CreateTexture1D() + { +// if(GLEW_VERSION_4_5||GLEW_ARB_direct_state_access||GL_EXT_direct_state_access) + return CreateTexture1DDSA(); +// else +// return CreateTexture1DBind(); + } + + Texture1D *CreateTexture1D(Texture1DData *ptr) + { + Texture1D *tex=CreateTexture1D(); + + if(!tex)RETURN_ERROR_NULL; + + tex->SetImage(ptr); + return(tex); + } + + Texture1D *CreateTexture1D(uint length, TSF format) + { + Texture1D *tex = CreateTexture1D(); + + if (!tex)RETURN_ERROR_NULL; + + tex->SetImage(length,format); + return(tex); + } + + Texture1D *CreateTexture1D(uint length, void *bitmap, uint bitmap_bytes, TSF source_format, uint video_format) + { + Texture1D *tex = CreateTexture1D(); + + if (!tex)RETURN_ERROR_NULL; + + tex->SetImage(length, bitmap,bitmap_bytes,source_format, video_format); + return(tex); + } + }//namespace graph +}//namespace hgl diff --git a/src/RenderDriver/Texture1DDSA.cpp b/src/RenderDriver/Texture1DDSA.cpp new file mode 100644 index 00000000..2a1a61a4 --- /dev/null +++ b/src/RenderDriver/Texture1DDSA.cpp @@ -0,0 +1,98 @@ +#include +#include + +namespace hgl +{ + namespace graph + { + class Texture1DDSA:public Texture1D + { + public: + + using Texture1D::Texture1D; + + bool _SetImage(Texture1DData *tex) override + { + glTextureStorage1D(texture_id, 1, tex->video_format, tex->length); + + if(!tex->bitmap) + return(true); + + if(tex->source_format->compress) //原本就是压缩格式 + glCompressedTextureSubImage1D(texture_id, 0, 0, tex->length, tex->video_format, tex->bitmap_bytes, tex->bitmap); + else //正常非压缩格式 + glTextureSubImage1D(texture_id, 0, 0, tex->length, tex->source_format->pixel_format, tex->source_format->data_type, tex->bitmap); + + if(tex->gen_mipmaps) + { + glGenerateTextureMipmap(texture_id); + + // glTexEnvf(GL_TEXTURE_FILTER_CONTROL,GL_TEXTURE_LOD_BIAS,-1.5f); //设置LOD偏向,负是更精细，正是更模糊 + } + + return(true); + } + + int _GetImage(void *data_pointer, TSF fmt, int level) override + { + int compress; + int bytes; + + const TextureFormat *tsf = TextureFormatInfoList + fmt; + + glGetTextureLevelParameteriv(texture_id, level, GL_TEXTURE_COMPRESSED, &compress); + + if (compress) + { + glGetTextureLevelParameteriv(texture_id, level, GL_TEXTURE_COMPRESSED_IMAGE_SIZE, &bytes); + + if (data_pointer) + glGetCompressedTextureImage(texture_id, level, bytes, data_pointer); + } + else + { + if (tsf->video_bytes == 0)return(-1); + + bytes = length*tsf->video_bytes; + + if (data_pointer) + glGetTextureImage(texture_id, level, tsf->pixel_format, tsf->data_type, bytes, data_pointer); + } + + return(bytes); + } + + bool _ChangeImage(uint s, uint l, void *data, uint bytes, TSF sf) override + { + const TextureFormat *sfmt = TextureFormatInfoList + sf; //原始数据格式 + + if (sfmt->compress) + glCompressedTextureSubImage1D(texture_id, 0, s, l, sfmt->video_format, bytes, data); + else + glTextureSubImage1D(texture_id, 0, s, l, sfmt->pixel_format, sfmt->data_type, data); + + return(true); + } + + void GenMipmaps() override + { + glGenerateTextureMipmap(texture_id); + } + + void GetMipmapLevel(int &base_level,int &max_level) override + { + glGetTextureParameteriv(texture_id,GL_TEXTURE_BASE_LEVEL,&base_level); + glGetTextureParameteriv(texture_id,GL_TEXTURE_MAX_LEVEL,&max_level); + } + };//class Texture1DDSA:public Texture1D + + Texture1D *CreateTexture1DDSA() + { + uint id; + + glCreateTextures(GL_TEXTURE_1D,1,&id); + + return(new Texture1DDSA(id)); + } + }//namespace graph +}//namespace hgl diff --git a/src/RenderDriver/Texture2D.cpp b/src/RenderDriver/Texture2D.cpp new file mode 100644 index 00000000..37b0aa8e --- /dev/null +++ b/src/RenderDriver/Texture2D.cpp @@ -0,0 +1,126 @@ +#include +#include +//#include + +namespace hgl +{ + namespace graph + { + bool Texture2D::SetImage(Texture2DData *ptr) + { + if (!ptr) + { + LOG_ERROR(OS_TEXT("param error,ptr=nullptr")); + RETURN_FALSE; + } + + if (!ptr->width || !ptr->height) + { + LOG_ERROR(OS_TEXT("size error,width=") + OSString(ptr->width) + OS_TEXT(",height=") + OSString(ptr->height)); + return(false); + } + + width = ptr->width; + height = ptr->height; + + video_format = ptr->GetVideoFormat(); + pixel_format = ptr->GetPixelFormat(); + + if (!_SetImage(ptr)) + { + width=height= 0; + RETURN_FALSE; + } + + return(true); + } + + int Texture2D::GetImage(void *data_pointer, TSF fmt, int level) + { + if (!TextureSourceFormatCheck(fmt)) + { + LOG_ERROR(OS_TEXT("glTexture2D::GetImage,fmt error =") + OSString(fmt)); + return(-1); + } + + return _GetImage(data_pointer,fmt,level,width,height); + } + + bool Texture2D::ChangeImage(uint l, uint t, uint w, uint h, void *data, uint bytes, TSF sf) + { + if (l>width || t>height + || w>width - l + || h>height - t + || !data + || !TextureSourceFormatCheck(sf)) + RETURN_FALSE; + + return _ChangeImage(l,t,w,h, data, bytes, sf); + } + }//namespace graph + + namespace graph + { + Texture2D *CreateTexture2DDSA(); + Texture2D *CreateTexture2DBind(); + + Texture2D *CreateTexture2D() + { + // if(GLEW_VERSION_4_5||GLEW_ARB_direct_state_access||GL_EXT_direct_state_access) + return CreateTexture2DDSA(); + // else + // return CreateTexture2DBind(); + } + + Texture2D *CreateTexture2D(Texture2DData *ptr) + { + Texture2D *tex = CreateTexture2D(); + + if (!tex)RETURN_ERROR_NULL; + + tex->SetImage(ptr); + return(tex); + } + + Texture2D *CreateTexture2D(uint width, uint height, TSF format) + { + Texture2D *tex = CreateTexture2D(); + + if (!tex)RETURN_ERROR_NULL; + + tex->SetImage(width,height,format); + return(tex); + } + + Texture2D *CreateTexture2D(uint width, uint height, void *bitmap, uint bitmap_bytes, TSF source_format, uint video_format) + { + Texture2D *tex = CreateTexture2D(); + + if (!tex)RETURN_ERROR_NULL; + + tex->SetImage(width,height, bitmap, bitmap_bytes, source_format, video_format); + return(tex); + } + +// Texture2D *CreateTexture2D(const OSString &filename,uint video_format) +// { +// Texture2D *tex = CreateTexture2D(); +// +// if (!tex)RETURN_ERROR_NULL; +// +// Bitmap2D bmp; +// +// if(!LoadBitmapFromFile(&bmp,filename)) +// RETURN_ERROR_NULL; +// +// tex->SetImage(bmp.GetWidth(), +// bmp.GetHeight(), +// bmp.GetData(), +// bmp.GetDataLength(), +// bmp.GetFormat(), +// video_format); +// +// return(tex); +// } + }//namespace graph +}//namespace hgl diff --git a/src/RenderDriver/Texture2DDSA.cpp b/src/RenderDriver/Texture2DDSA.cpp new file mode 100644 index 00000000..fa074cb1 --- /dev/null +++ b/src/RenderDriver/Texture2DDSA.cpp @@ -0,0 +1,98 @@ +#include +#include + +namespace hgl +{ + namespace graph + { + class Texture2DDSA:public Texture2D + { + public: + + using Texture2D::Texture2D; + + bool _SetImage(Texture2DData *tex) override + { + glTextureStorage2D(texture_id, 1, tex->video_format, tex->width, tex->height); + + if(!tex->bitmap) + return(true); + + if(tex->source_format->compress) //原本就是压缩格式 + glCompressedTextureSubImage2D(texture_id, 0, 0, 0, tex->width, tex->height, tex->video_format, tex->bitmap_bytes, tex->bitmap); + else //正常非压缩格式 + glTextureSubImage2D(texture_id, 0, 0, 0, tex->width, tex->height, tex->source_format->pixel_format, tex->source_format->data_type, tex->bitmap); + + if(tex->gen_mipmaps) + { + glGenerateTextureMipmap(texture_id); + + // glTexEnvf(GL_TEXTURE_FILTER_CONTROL,GL_TEXTURE_LOD_BIAS,-1.5f); //设置LOD偏向,负是更精细，正是更模糊 + } + + return(true); + } + + int _GetImage(void *data_pointer, TSF fmt, int level,int width,int height) override + { + int compress; + int bytes; + + const TextureFormat *tsf = TextureFormatInfoList + fmt; + + glGetTextureLevelParameteriv(texture_id, level, GL_TEXTURE_COMPRESSED, &compress); + + if (compress) + { + glGetTextureLevelParameteriv(texture_id, level, GL_TEXTURE_COMPRESSED_IMAGE_SIZE, &bytes); + + if (data_pointer) + glGetCompressedTextureImage(texture_id, level, bytes, data_pointer); + } + else + { + if (tsf->video_bytes == 0)return(-1); + + bytes = width*height*tsf->video_bytes; + + if (data_pointer) + glGetTextureImage(texture_id, level, tsf->pixel_format, tsf->data_type, bytes, data_pointer); + } + + return(bytes); + } + + bool _ChangeImage(uint l, uint t, uint w, uint h, void *data, uint bytes, TSF sf) override + { + const TextureFormat *sfmt = TextureFormatInfoList + sf; //原始数据格式 + + if (sfmt->compress) + glCompressedTextureSubImage2D(texture_id, 0, l, t, w, h, sfmt->video_format, bytes, data); + else + glTextureSubImage2D(texture_id, 0, l, t, w, h, sfmt->pixel_format, sfmt->data_type, data); + + return(true); + } + + void GenMipmaps() override + { + glGenerateTextureMipmap(texture_id); + } + + void GetMipmapLevel(int &base_level,int &max_level) override + { + glGetTextureParameteriv(texture_id,GL_TEXTURE_BASE_LEVEL,&base_level); + glGetTextureParameteriv(texture_id,GL_TEXTURE_MAX_LEVEL,&max_level); + } + };//class Texture2DDSA + + Texture2D *CreateTexture2DDSA() + { + uint id; + + glCreateTextures(GL_TEXTURE_2D,1,&id); + + return(new Texture2DDSA(id)); + } + }//namespace graph +}//namespace hgl diff --git a/src/RenderDriver/TextureFormat.cpp b/src/RenderDriver/TextureFormat.cpp new file mode 100644 index 00000000..b939f1fe --- /dev/null +++ b/src/RenderDriver/TextureFormat.cpp @@ -0,0 +1,137 @@ +#include +namespace hgl +{ + namespace graph + { + //贴图数据源格式 + const TextureFormat TextureFormatInfoList[]= + { + {HGL_SF_NONE, "", false, 0, 0, GL_RGBA, GL_UNSIGNED_BYTE ,0,0}, + + {HGL_SF_R8, "R8", false, 0, GL_R8, GL_RED, GL_UNSIGNED_BYTE ,1,1}, + {HGL_SF_RG8, "RG8", false, 0, GL_RG8, GL_RG, GL_UNSIGNED_BYTE ,2,2}, + {HGL_SF_RGB8, "RGB8", false, 0, GL_RGB8, GL_RGB, GL_UNSIGNED_BYTE ,3,3}, + {HGL_SF_RGBA8, "RGBA8", false, 0, GL_RGBA8, GL_RGBA, GL_UNSIGNED_BYTE ,4,4}, + + {HGL_SF_SRGB8, "SRGB8", false, 0, GL_SRGB8, GL_SRGB, GL_UNSIGNED_BYTE ,4,4}, + {HGL_SF_SRGBA8, "SRGBA8", false, 0, GL_SRGB8_ALPHA8, GL_SRGB_ALPHA, GL_UNSIGNED_BYTE ,5,5}, + + {HGL_SF_R16, "R16", false, 0, GL_R16, GL_RED, GL_UNSIGNED_SHORT ,2,2}, + {HGL_SF_RG16, "RG16", false, 0, GL_RG16, GL_RG, GL_UNSIGNED_SHORT ,4,4}, + {HGL_SF_RGB16, "RGB16", false, 0, GL_RGB16, GL_RGB, GL_UNSIGNED_SHORT ,6,6}, + {HGL_SF_RGBA16, "RGBA16", false, 0, GL_RGBA16, GL_RGBA, GL_UNSIGNED_SHORT ,8,8}, + + {HGL_SF_R16F, "R16F", false, 0, GL_R16F, GL_RED, GL_FLOAT ,2,2}, + {HGL_SF_RG16F, "RG16F", false, 0, GL_RG16F, GL_RG, GL_FLOAT ,4,4}, + {HGL_SF_RGB16F, "RGB16F", false, 0, GL_RGB16F, GL_RGB, GL_FLOAT ,6,6}, + {HGL_SF_RGBA16F, "RGBA16F", false, 0, GL_RGBA16F, GL_RGBA, GL_FLOAT ,8,8}, + + {HGL_SF_R32F, "R32F", false, 0, GL_R32F, GL_RED, GL_FLOAT ,4,4}, + {HGL_SF_RG32F, "RG32F", false, 0, GL_RG32F, GL_RG, GL_FLOAT ,8,8}, + {HGL_SF_RGB32F, "RGB32F", false, 0, GL_RGB32F, GL_RGB, GL_FLOAT ,12,12}, + {HGL_SF_RGBA32F, "RGBA32F", false, 0, GL_RGBA32F, GL_RGBA, GL_FLOAT ,16,16}, + + {HGL_SF_UNCOMPRESSED, "", false, 0, 0, 0, 0 ,0,0}, + + {HGL_SF_R3_G3_B2, "R3_G3_B2", false, 0, GL_R3_G3_B2, GL_RGB, GL_UNSIGNED_BYTE_3_3_2 ,1,1}, + {HGL_SF_RGB565, "RGB565", false, 0, GL_RGB565, GL_RGB, GL_UNSIGNED_SHORT_5_6_5 ,2,2}, + + {HGL_SF_RGBA4, "RGBA4", false, 0, GL_RGBA4, GL_RGBA, GL_UNSIGNED_SHORT_4_4_4_4 ,2,2}, + {HGL_SF_RGB5_A1, "RGB5_A1", false, 0, GL_RGB5_A1, GL_RGBA, GL_UNSIGNED_SHORT_5_5_5_1 ,2,2}, + {HGL_SF_RGB10_A2, "RGB10_A2", false, 0, GL_RGB10_A2, GL_RGBA, GL_UNSIGNED_INT_10_10_10_2 ,4,4}, + + {HGL_SF_RG11F_B10F, "RG11F_B10F", false, 0, GL_R11F_G11F_B10F, GL_RGB, GL_UNSIGNED_INT_10F_11F_11F_REV ,4,4}, + {HGL_SF_RGB9_E5, "RGB9_E5", false, 0, GL_RGB9_E5, GL_RGB, GL_UNSIGNED_INT_5_9_9_9_REV ,4,4}, + + {HGL_SF_DEPTH, "", false, 0, 0, 0, 0 ,0,0}, + + {HGL_SF_DEPTH16, "DEPTH16", false, 0, GL_DEPTH_COMPONENT16, GL_DEPTH, GL_UNSIGNED_SHORT ,2,2}, + {HGL_SF_DEPTH24, "DEPTH24", false, 0, GL_DEPTH_COMPONENT24, GL_DEPTH, GL_UNSIGNED_BYTE ,3,3}, + {HGL_SF_DEPTH32, "DEPTH32", false, 0, GL_DEPTH_COMPONENT32, GL_DEPTH, GL_UNSIGNED_INT ,4,4}, + + {HGL_SF_DEPTH32F, "DEPTH32F", false, 0, GL_DEPTH_COMPONENT32F, GL_DEPTH, GL_FLOAT ,4,4}, + + {HGL_SF_INDEX, "", false, 0, 0, 0, 0 ,0,0}, + + {HGL_SF_INDEX_16_RGB, "16RGB", false, 16, GL_LUMINANCE4, GL_RGB, GL_UNSIGNED_BYTE ,0,0}, + {HGL_SF_INDEX_16_RGBA, "16RGBA", false, 16, GL_LUMINANCE4, GL_RGBA, GL_UNSIGNED_BYTE ,0,0}, + {HGL_SF_INDEX_256_RGB, "256RGB", false, 256,GL_LUMINANCE8, GL_RGB, GL_UNSIGNED_BYTE ,0,0}, + {HGL_SF_INDEX_256_RGBA, "256RGBA", false, 256,GL_LUMINANCE8, GL_RGBA, GL_UNSIGNED_BYTE ,0,0}, + + {HGL_SF_COMPRESSED, "", false, 0, 0, 0, 0 ,0,0}, +/* + {HGL_SF_CR, "CR", true, 0, GL_COMPRESSED_RED, GL_RED, 0,0,0}, //注：GL_COMPRESSED RED/RG/RGB/RGBA/SRGB/SRGBA这6个格式 + {HGL_SF_CRG, "CRG", true, 0, GL_COMPRESSED_RG, GL_RG, 0,0,0}, //只能用于glTexImage，由于显卡并不一定确定最终用什么算法， + {HGL_SF_CRGB, "CRGB", true, 0, GL_COMPRESSED_RGB, GL_RGB, 0,0,0}, //所以用glGetCompressTexImage取出的数据，不能在glCompressTexImage中用 + {HGL_SF_CRGBA, "CRGBA", true, 0, GL_COMPRESSED_RGBA, GL_RGBA, 0,0,0}, + + {HGL_SF_CSRGB, "CSRGB", true, 0, GL_COMPRESSED_SRGB, GL_SRGB, 0,0,0}, + {HGL_SF_CSRGBA, "CSRGBA", true, 0, GL_COMPRESSED_SRGB_ALPHA, GL_SRGB_ALPHA, 0,0,0}, +*/ + {HGL_SF_DXT1RGB, "DXT1RGB", true, 0, GL_COMPRESSED_RGB_S3TC_DXT1_EXT, GL_RGB, 0,0,0}, + {HGL_SF_DXT1RGBA, "DXT1RGBA", true, 0, GL_COMPRESSED_RGBA_S3TC_DXT1_EXT, GL_RGBA, 0,0,0}, + {HGL_SF_DXT3RGBA, "DXT3RGBA", true, 0, GL_COMPRESSED_RGBA_S3TC_DXT3_EXT, GL_RGBA, 0,0,0}, + {HGL_SF_DXT5RGBA, "DXT5RGBA", true, 0, GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, GL_RGBA, 0,0,0}, + + {HGL_SF_LATC1, "LATC1", true, 0, GL_COMPRESSED_LUMINANCE_LATC1_EXT, GL_RED, 0,0,0}, + {HGL_SF_LATC1s, "LATC1s", true, 0, GL_COMPRESSED_SIGNED_LUMINANCE_LATC1_EXT, GL_RED, 0,0,0}, + {HGL_SF_LATC2, "LATC2", true, 0, GL_COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT, GL_RG, 0,0,0}, + {HGL_SF_LATC2s, "LATC2s", true, 0, GL_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2_EXT, GL_RG, 0,0,0}, + + {HGL_SF_RGTC1, "RGTC1", true, 0, GL_COMPRESSED_RED_RGTC1, GL_RED, 0,0,0}, + {HGL_SF_RGTC1s, "RGTC1s", true, 0, GL_COMPRESSED_SIGNED_RED_RGTC1, GL_RED, 0,0,0}, + {HGL_SF_RGTC2, "RGTC2", true, 0, GL_COMPRESSED_RG_RGTC2, GL_RG, 0,0,0}, + {HGL_SF_RGTC2s, "RGTC2s", true, 0, GL_COMPRESSED_SIGNED_RG_RGTC2, GL_RG, 0,0,0}, + + {HGL_SF_BPTC_RGBf, "BPTC_RGBf", true, 0, GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT, GL_RGB, 0,0,0}, + {HGL_SF_BPTC_RGBuf, "BPTC_RGBuf", true, 0, GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT, GL_RGB, 0,0,0}, + {HGL_SF_BPTC_RGBA, "BPTC_RGBA", true, 0, GL_COMPRESSED_RGBA_BPTC_UNORM, GL_RGBA, 0,0,0}, + {HGL_SF_BPTC_SRGBA, "BPTC_SRGBA", true, 0, GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM, GL_SRGB_ALPHA, 0,0,0}, + + {HGL_SF_ETC2_RGB8, "ETC2_RGB8", true, 0, GL_COMPRESSED_RGB8_ETC2, GL_RGB, 0,0,0}, + {HGL_SF_ETC2_SRGB8, "ETC2_SRGB8", true, 0, GL_COMPRESSED_SRGB8_ETC2, GL_SRGB, 0,0,0}, + {HGL_SF_ETC2_RGB8A1, "ETC2_RGB8A1", true, 0, GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2, GL_RGBA, 0,0,0}, + {HGL_SF_ETC2_SRGB8A1, "ETC2_SRGB8A1", true, 0, GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2, GL_SRGB_ALPHA, 0,0,0}, + {HGL_SF_ETC2_RGBA8, "ETC2_RGBA8", true, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, GL_RGBA, 0,0,0}, + {HGL_SF_ETC2_SRGBA8, "ETC2_SRGBA8", true, 0, GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC, GL_SRGB_ALPHA, 0,0,0}, + + {HGL_SF_EAC_R11, "EAC_R11", true, 0, GL_COMPRESSED_R11_EAC, GL_RED, 0,0,0}, + {HGL_SF_EAC_R11s, "EAC_R11s", true, 0, GL_COMPRESSED_SIGNED_R11_EAC, GL_RED, 0,0,0}, + {HGL_SF_EAC_RG11, "EAC_RG11", true, 0, GL_COMPRESSED_RG11_EAC, GL_RG, 0,0,0}, + {HGL_SF_EAC_RG11s, "EAC_RG11s", true, 0, GL_COMPRESSED_SIGNED_RG11_EAC, GL_RG, 0,0,0} + };//const TextureFormat TextureFormatInfoList[] + + const int TextureFormatCount=sizeof(TextureFormatInfoList)/sizeof(TextureFormat); + + bool TextureSourceFormatCheck(const TextureSourceFormat &tsf) + { + if(tsf<=HGL_SF_NONE + ||tsf>=HGL_SF_END + ||tsf==HGL_SF_UNCOMPRESSED + ||tsf==HGL_SF_INDEX + ||tsf==HGL_SF_COMPRESSED) + return(false); + + return(true); + } + + bool TextureSourceFormatDepthCheck(const TextureSourceFormat &tsf) + { + return (tsf>HGL_SF_DEPTH&&tsf