// =====================================================================================================================
//  fennec, a free and open source game engine
//  Copyright © 2025 - 2026  Medusa Slockbower
//
//  This program is free software: you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation, either version 3 of the License, or
//  (at your option) any later version.
//
//  This program is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU General Public License for more details.
//
//  You should have received a copy of the GNU General Public License
//  along with this program.  If not, see <https://www.gnu.org/licenses/>.
// =====================================================================================================================

///
/// \file fennec/renderers/opengl/lib/enum.h
/// \brief
///
///
/// \details
/// \author Medusa Slockbower
///
/// \copyright Copyright © 2025 - 2026 Medusa Slockbower ([GPLv3](https://www.gnu.org/licenses/gpl-3.0.en.html))
///
///

#ifndef FENNEC_RENDERERS_OPENGL_LIB_ENUM_H
#define FENNEC_RENDERERS_OPENGL_LIB_ENUM_H

#include <fennec/renderers/opengl/lib/forward.h>

namespace fennec
{

namespace gl
{

// Buffer Types ========================================================================================================

///
/// \brief OpenGL Buffer Types
enum buffer_types : GLenum {
	VERTEX             = GL_ARRAY_BUFFER,              //!< Vertex Buffer
	ELEMENT            = GL_ELEMENT_ARRAY_BUFFER,      //!< Element Array Buffer
	UNIFORM            = GL_UNIFORM_BUFFER,            //!< Uniform Buffer
	SHADER_STORAGE     = GL_SHADER_STORAGE_BUFFER,     //!< Shader Storage Buffer
	QUERY              = GL_QUERY_BUFFER,              //!< Query Buffer
	BUFFER_TEXTURE     = GL_TEXTURE_BUFFER,            //!< Texture Buffer
	TRANSFORM_FEEDBACK = GL_TRANSFORM_FEEDBACK_BUFFER, //!< Transform Feedback Buffer
	ATOMIC_COUNTER     = GL_ATOMIC_COUNTER_BUFFER,     //!< Atomic Counter Buffer
	PARAMETER          = GL_PARAMETER_BUFFER,          //!< Parameter Buffer
	INDIRECT_DRAW      = GL_DRAW_INDIRECT_BUFFER,      //!< Indirect Draw Buffer
	INDIRECT_DISPATCH  = GL_DISPATCH_INDIRECT_BUFFER,  //!< Indirect Dispatch Buffer
	COPY_READ          = GL_COPY_READ_BUFFER,          //!< Copy Read Buffer
	COPY_WRITE         = GL_COPY_WRITE_BUFFER,         //!< Copy Write Buffer
	PIXEL_PACK         = GL_PIXEL_PACK_BUFFER,         //!< Pixel Pack Buffer
	PIXEL_UNPACK       = GL_PIXEL_UNPACK_BUFFER,       //!< Pixel Unpack Buffer
};


// Buffer Flags ========================================================================================================

///
/// \brief OpenGL Buffer Flags
enum buffer_map_flags : GLbitfield {
	READ           = GL_MAP_READ_BIT,              //!< Buffer Read Flag
	WRITE          = GL_MAP_WRITE_BIT,             //!< Buffer Write Flag
	DYNAMIC        = GL_DYNAMIC_STORAGE_BIT,       //!< Dynamic Buffer Flag
	PERSISTENT     = GL_MAP_PERSISTENT_BIT,        //!< Persistent Buffer Flag
	COHERENT       = GL_MAP_COHERENT_BIT,          //!< Coherent Buffer Flag
	CLIENT         = GL_CLIENT_STORAGE_BIT,        //!< Client Allocated Buffer Flag
	EXPLICIT_FLUSH = GL_MAP_FLUSH_EXPLICIT_BIT,    //!< Explicit Flush Flag
	INVALIDATE     = GL_MAP_INVALIDATE_BUFFER_BIT, //!< Invalidation Flag
};


// Buffer Access =======================================================================================================

///
/// \brief OpenGL Buffer Access
enum buffer_access : GLbitfield {
	READ_ONLY      = GL_READ_ONLY,  //!< Read Only Flag
	WRITE_ONLY     = GL_WRITE_ONLY, //!< Write Only Flag
	READ_WRITE     = GL_READ_WRITE, //!< Read & Write Flag
};


// Texture Types =======================================================================================================

///
/// \brief OpenGL Texture Types
enum texture_types : GLenum {
	TEXTURE_1D          = GL_TEXTURE_1D,                   //!< 1D Texture
	TEXTURE_1D_ARRAY    = GL_TEXTURE_1D_ARRAY,             //!< 1D Texture Array
	TEXTURE_2D          = GL_TEXTURE_2D,                   //!< 2D Texture
	TEXTURE_2D_ARRAY    = GL_TEXTURE_2D_ARRAY,             //!< 2D Texture Array
	TEXTURE_2D_MS       = GL_TEXTURE_2D_MULTISAMPLE,       //!< 2D Multisampled Texture
	TEXTURE_2D_MS_ARRAY = GL_TEXTURE_2D_MULTISAMPLE_ARRAY, //!< 2D Multisampled Texture Array
	TEXTURE_RECTANGLE   = GL_TEXTURE_RECTANGLE,            //!< 2D Texture Rectangle
	CUBEMAP             = GL_TEXTURE_CUBE_MAP,             //!< Cubemap
	CUBEMAP_ARRAY       = GL_TEXTURE_CUBE_MAP_ARRAY,       //!< Cubemap Array
	TEXTURE_3D          = GL_TEXTURE_3D,                   //!< 3D Texture
};


// Cubemap Faces =======================================================================================================

///
/// \brief OpenGL Cubemap Faces
enum cubemap_faces : GLenum {
	CUBEMAP_POSITIVE_X = GL_TEXTURE_CUBE_MAP_POSITIVE_X, //!< Cube Map +X Face
	CUBEMAP_NEGATIVE_X = GL_TEXTURE_CUBE_MAP_NEGATIVE_X, //!< Cube Map -X Face
	CUBEMAP_POSITIVE_Y = GL_TEXTURE_CUBE_MAP_POSITIVE_Y, //!< Cube Map +Y Face
	CUBEMAP_NEGATIVE_Y = GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, //!< Cube Map -Y Face
	CUBEMAP_POSITIVE_Z = GL_TEXTURE_CUBE_MAP_POSITIVE_Z, //!< Cube Map +Z Face
	CUBEMAP_NEGATIVE_Z = GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, //!< Cube Map -Z Face
};


// Built-In Types ======================================================================================================

///
/// \brief OpenGL Built-In Types
enum types : GLenum {

// Basic Types ---------------------------------------------------------------------------------------------------------

	BOOL   = GL_BOOL,           //!< Boolean Type
	BYTE   = GL_BYTE,           //!< Byte Type
	UBYTE  = GL_UNSIGNED_BYTE,  //!< Unsigned Byte Type
	SHORT  = GL_SHORT,          //!< Short Type
	USHORT = GL_UNSIGNED_SHORT, //!< Unsigned Short Type
	INT    = GL_INT,            //!< Integer Type
	UINT   = GL_UNSIGNED_INT,   //!< Unsigned Integer Type
	HALF    = GL_HALF_FLOAT,    //!< Half Precision Floating Point Type
	FLOAT   = GL_FLOAT,         //!< Floating Point Type
	DOUBLE  = GL_DOUBLE,        //!< Double Precision Floating Point Type


// Vector Types --------------------------------------------------------------------------------------------------------

	BVEC2  = GL_BOOL_VEC2,         //!< 2D Boolean Vector Type
	BVEC3  = GL_BOOL_VEC3,         //!< 3D Boolean Vector Type
	BVEC4  = GL_BOOL_VEC4,         //!< 4D Boolean Vector Type

	IVEC2  = GL_INT_VEC2,          //!< 2D Integer Vector Type
	IVEC3  = GL_INT_VEC3,          //!< 3D Integer Vector Type
	IVEC4  = GL_INT_VEC4,          //!< 4D Integer Vector Type

	UVEC2  = GL_UNSIGNED_INT_VEC2, //!< 2D Unsigned Integer Vector Type
	UVEC3  = GL_UNSIGNED_INT_VEC3, //!< 3D Unsigned Integer Vector Type
	UVEC4  = GL_UNSIGNED_INT_VEC4, //!< 4D Unsigned Integer Vector Type

	VEC2    = GL_FLOAT_VEC2,       //!< 2D Floating Point Vector Type
	VEC3    = GL_FLOAT_VEC3,       //!< 3D Floating Point Vector Type
	VEC4    = GL_FLOAT_VEC4,       //!< 4D Floating Point Vector Type

	DVEC2   = GL_DOUBLE_VEC2,      //!< 2D Double Precision Floating Point Type
	DVEC3   = GL_DOUBLE_VEC3,      //!< 3D Double Precision Floating Point Type
	DVEC4   = GL_DOUBLE_VEC4,      //!< 4D Double Precision Floating Point Type


// Packed Types --------------------------------------------------------------------------------------------------------

	UBYTE332      = GL_UNSIGNED_BYTE_3_3_2,         //!< Packed RGB  Type with  3 Red,  3 Green, and 2 Blue bits.
	UBYTE233R     = GL_UNSIGNED_BYTE_2_3_3_REV,     //!< Packed BGR  Type with  3 Red,  3 Green, and 2 Blue bits.
	USHORT565     = GL_UNSIGNED_SHORT_5_6_5,        //!< Packed RGB  Type with  5 Red,  6 Green, and 5 Blue bits.
	USHORT565R    = GL_UNSIGNED_SHORT_5_6_5_REV,    //!< Packed BGR  Type with  5 Red,  6 Green, and 5 Blue bits.

	USHORT4444    = GL_UNSIGNED_SHORT_4_4_4_4,      //!< Packed RGBA Type with  4 Red,  4 Green,  4 Blue, and 4 Alpha bits.
	USHORT4444R   = GL_UNSIGNED_SHORT_4_4_4_4_REV,  //!< Packed BGRA Type with  4 Red,  4 Green,  4 Blue, and 4 Alpha bits.
	USHORT5551    = GL_UNSIGNED_SHORT_5_5_5_1,      //!< Packed RGBA Type with  5 Red,  5 Green,  5 Blue, and 1 Alpha bits.
	USHORT1555R   = GL_UNSIGNED_SHORT_1_5_5_5_REV,  //!< Packed BGRA Type with  5 Red,  5 Green,  5 Blue, and 1 Alpha bits.
	UINT8888      = GL_UNSIGNED_INT_8_8_8_8,        //!< Packed RGBA Type with  8 Red,  8 Green,  8 Blue, and 8 Alpha bits.
	UINT8888R     = GL_UNSIGNED_INT_8_8_8_8_REV,    //!< Packed BGRA Type with  8 Red,  8 Green,  8 Blue, and 8 Alpha bits.
	UINT5999R     = GL_UNSIGNED_INT_5_9_9_9_REV,    //!< Packed BGRA Type with  9 Red,  9 Green,  9 Blue, and 5 Alpha bits.
	UINTAAA2      = GL_UNSIGNED_INT_10_10_10_2,     //!< Packed RGBA Type with 10 Red, 10 Green, 10 Blue, and 2 Alpha bits.
	UINT2AAAR     = GL_UNSIGNED_INT_2_10_10_10_REV, //!< Packed BGRA Type with 10 Red, 10 Green, 10 Blue, and 2 Alpha bits.

	UINT24_8      = GL_UNSIGNED_INT_24_8,              //!< Packed DS   Type with 24 Depth and 8 Stencil bits.
	FLOAT32UINT24 = GL_FLOAT_32_UNSIGNED_INT_24_8_REV, //!< Packed DS Type with 32 Depth and 8 Stencil bits.

	UINTABBFR     = GL_UNSIGNED_INT_10F_11F_11F_REV, //!< Packed ZXY Type with 10 X, 11 Y, and 11 Z bits.


// Samplers Types ------------------------------------------------------------------------------------------------------

	SAMPLER_1D                   = GL_SAMPLER_1D,                    //!< 1D Texture Sampler
	SAMPLER_1D_ARRAY             = GL_SAMPLER_1D_ARRAY,              //!< 1D Texture Sampler Array
	SHADOW_SAMPLER_1D            = GL_SAMPLER_1D_SHADOW,             //!< 1D Shadow Texture Sampler
	SHADOW_SAMPLER_1D_ARRAY      = GL_SAMPLER_1D_ARRAY_SHADOW,       //!< 1D Shadow Texture Sampler Array
	SAMPLER_2D                   = GL_SAMPLER_2D,                    //!< 2D Texture Sampler
	SAMPLER_2D_ARRAY             = GL_SAMPLER_2D_ARRAY,              //!< 2D Texture Sampler Array
	SAMPLER_RECT_2D              = GL_SAMPLER_2D_RECT,               //!< 2D Texture Rectangle Sampler
	SAMPLER_2D_MS                = GL_SAMPLER_2D_MULTISAMPLE,        //!< 2D Multi-Sampled Texture Sampler
	SAMPLER_2D_MS_ARRAY          = GL_SAMPLER_2D_MULTISAMPLE_ARRAY,  //!< 2D Multi-Sampled Texture Sampler Array
	SHADOW_SAMPLER_2D            = GL_SAMPLER_2D_SHADOW,             //!< 2D Shadow Texture Sampler
	SHADOW_SAMPLER_2D_ARRAY      = GL_SAMPLER_2D_ARRAY_SHADOW,       //!< 2D Shadow Texture Sampler Array
	SHADOW_SAMPLER_RECT_2D       = GL_SAMPLER_2D_RECT_SHADOW,        //!< 2D Shadow Texture Rectangle Sampler
	CUBEMAP_SAMPLER              = GL_SAMPLER_CUBE,                  //!< Cubemap Sampler
	CUBEMAP_SAMPLER_ARRAY        = GL_SAMPLER_CUBE_MAP_ARRAY,        //!< Cubemap Sampler Array
	SHADOW_CUBEMAP_SAMPLER       = GL_SAMPLER_CUBE_SHADOW,           //!< Shadow Cubemap Sampler
	SHADOW_CUBEMAP_SAMPLER_ARRAY = GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW, //!< Shadow Cubemap Sampler Array
	SAMPLER_3D                   = GL_SAMPLER_3D,                    //!< 3D Texture Sampler
	BUFFER_SAMPLER               = GL_SAMPLER_BUFFER,                //!< Buffer Texture Sampler

	ISAMPLER_1D            = GL_INT_SAMPLER_1D,                   //!< 1D Integer Texture Sampler
	ISAMPLER_1D_ARRAY      = GL_INT_SAMPLER_1D_ARRAY,             //!< 1D Integer Texture Sampler Array
	ISAMPLER_2D            = GL_INT_SAMPLER_2D,                   //!< 2D Integer Texture Sampler
	ISAMPLER_2D_ARRAY      = GL_INT_SAMPLER_2D_ARRAY,             //!< 2D Integer Texture Sampler Array
	ISAMPLER_RECT_2D       = GL_INT_SAMPLER_2D_RECT,              //!< 2D Integer Texture Rectangle Sampler
	ISAMPLER_2D_MS         = GL_INT_SAMPLER_2D_MULTISAMPLE,       //!< 2D Integer Multi-Sampled Texture Sampler
	ISAMPLER_2D_MS_ARRAY   = GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY, //!< 2D Integer Multi-Sampled Texture Sampler Array
	ISAMPLER_3D            = GL_INT_SAMPLER_3D,                   //!< 3D Integer Texture Sampler
	BUFFER_ISAMPLER        = GL_INT_SAMPLER_BUFFER,               //!< Integer Buffer Texture Sampler
	CUBEMAP_ISAMPLER       = GL_INT_SAMPLER_CUBE,                 //!< Integer Cubemap Sampler
	CUBEMAP_ISAMPLER_ARRAY = GL_INT_SAMPLER_CUBE_MAP_ARRAY,       //!< Integer Cubemap Sampler Array


	USAMPLER_1D            = GL_UNSIGNED_INT_SAMPLER_1D,                   //!< 1D Unsigned Integer Texture Sampler
	USAMPLER_1D_ARRAY      = GL_UNSIGNED_INT_SAMPLER_1D_ARRAY,             //!< 1D Unsigned Integer Texture Sampler Array
	USAMPLER_2D            = GL_UNSIGNED_INT_SAMPLER_2D,                   //!< 2D Unsigned Integer Texture Sampler
	USAMPLER_2D_ARRAY      = GL_UNSIGNED_INT_SAMPLER_2D_ARRAY,             //!< 2D Unsigned Integer Texture Sampler Array
	USAMPLER_RECT_2D       = GL_UNSIGNED_INT_SAMPLER_2D_RECT,              //!< 2D Unsigned Integer Texture Rectangle Sampler
	USAMPLER_2D_MS         = GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE,       //!< 2D Unsigned Integer Multi-Sampled Texture Sampler
	USAMPLER_2D_MS_ARRAY   = GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY, //!< 2D Unsigned Integer Multi-Sampled Texture Sampler Array
	USAMPLER_3D            = GL_UNSIGNED_INT_SAMPLER_3D,                   //!< 3D Unsigned Integer Texture Sampler
	BUFFER_USAMPLER        = GL_UNSIGNED_INT_SAMPLER_BUFFER,               //!< Unsigned Integer Buffer Texture Sampler
	CUBEMAP_USAMPLER       = GL_UNSIGNED_INT_SAMPLER_CUBE,                 //!< Unsigned Integer Cubemap Sampler
	CUBEMAP_USAMPLER_ARRAY = GL_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY,       //!< Unsigned Integer Cubemap Sampler Array


// Image Types ---------------------------------------------------------------------------------------------------------

	IMAGE_1D            = GL_IMAGE_1D,                   //!< 1D Image
	IMAGE_1D_ARRAY      = GL_IMAGE_1D_ARRAY,             //!< 1D Image Array
	IMAGE_2D            = GL_IMAGE_2D,                   //!< 2D Image
	IMAGE_2D_ARRAY      = GL_IMAGE_2D_ARRAY,             //!< 2D Image Array
	IMAGE_RECT_2D       = GL_IMAGE_2D_RECT,              //!< 2D Image Rectangle
	IMAGE_2D_MS         = GL_IMAGE_2D_MULTISAMPLE,       //!< 2D Multi-Sampled Image
	IMAGE_2D_MS_ARRAY   = GL_IMAGE_2D_MULTISAMPLE_ARRAY, //!< 2D Multi-Sampled Image Array
	IMAGE_3D            = GL_IMAGE_3D,                   //!< 3D Image
	IMAGE_BUFFER        = GL_IMAGE_BUFFER,               //!< Image Buffer
	IMAGE_CUBEMAP       = GL_IMAGE_CUBE,                 //!< Cubemap Image
	IMAGE_CUBEMAP_ARRAY = GL_IMAGE_CUBE_MAP_ARRAY,       //!< Cubemap Image Array

	IIMAGE_1D          = GL_INT_IMAGE_1D,                   //!< 1D Integer Image
	IIMAGE_1D_ARRAY    = GL_INT_IMAGE_1D_ARRAY,             //!< 1D Integer Image Array
	IIMAGE_2D          = GL_INT_IMAGE_2D,                   //!< 2D Integer Image
	IIMAGE_2D_ARRAY    = GL_INT_IMAGE_2D_ARRAY,             //!< 2D Integer Image Array
	IIMAGE_RECT_2D     = GL_INT_IMAGE_2D_RECT,              //!< 2D Integer Image Rectangle
	IIMAGE_2D_MS       = GL_INT_IMAGE_2D_MULTISAMPLE,       //!< 2D Multi-Sampled Integer Image
	IIMAGE_2D_MS_ARRAY = GL_INT_IMAGE_2D_MULTISAMPLE_ARRAY, //!< 2D Multi-Sampled Integer Image Array
	IIMAGE_3D          = GL_INT_IMAGE_3D,                   //!< 3D Integer Image
	IIMAGE_BUFFER      = GL_INT_IMAGE_BUFFER,               //!< Integer Image Buffer
	IIMAGE_CUBEMAP     = GL_INT_IMAGE_CUBE,                 //!< Integer Cubemap Image

	UIMAGE_1D          = GL_UNSIGNED_INT_IMAGE_1D,                   //!< 1D Unsigned Integer Image
	UIMAGE_1D_ARRAY    = GL_UNSIGNED_INT_IMAGE_1D_ARRAY,             //!< 1D Unsigned Integer Image Array
	UIMAGE_2D          = GL_UNSIGNED_INT_IMAGE_2D,                   //!< 2D Unsigned Integer Image
	UIMAGE_2D_ARRAY    = GL_UNSIGNED_INT_IMAGE_2D_ARRAY,             //!< 2D Unsigned Integer Image Array
	UIMAGE_RECT_2D     = GL_UNSIGNED_INT_IMAGE_2D_RECT,              //!< 2D Unsigned Integer Image Rectangle
	UIMAGE_2D_MS       = GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE,       //!< 2D Multi-Sampled Unsigned Integer Image
	UIMAGE_2D_MS_ARRAY = GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY, //!< 2D Multi-Sampled Unsigned Integer Image Array
	UIMAGE_3D          = GL_UNSIGNED_INT_IMAGE_3D,                   //!< 3D Unsigned Integer Image
	UIMAGE_BUFFER      = GL_UNSIGNED_INT_IMAGE_BUFFER,               //!< Unsigned Integer Image Buffer
	UIMAGE_CUBEMAP     = GL_UNSIGNED_INT_IMAGE_CUBE,                 //!< Unsigned Integer Cubemap Image

	UINT_ATOMIC_COUNTER = GL_UNSIGNED_INT_ATOMIC_COUNTER, //!< Atomic Counter
};


// Pixel Components ====================================================================================================

///
/// \brief OpenGL Pixel Components
enum pixel_components : GLenum {
	ZERO          = GL_ZERO,  //!< Interpret as 0
	ONE           = GL_ONE,   //!< Interpret as 1
	R             = GL_RED,   //!< Red Component
	G             = GL_GREEN, //!< Green Component
	B             = GL_BLUE,  //!< Blue Component
	A             = GL_ALPHA, //!< Alpha Component
	RGB           = GL_RGB,   //!< Combined Red-Green-Blue
	BGR           = GL_BGR,   //!< Combined Blue-Green-Red
	RGBA          = GL_RGBA,  //!< Combined Red-Green-Blue-Alpha
	BGRA          = GL_BGRA,  //!< Combined Blue-Green-Red-Alpha

	R_INT         = GL_RED_INTEGER,       //!< Integral Red Component
	G_INT         = GL_GREEN_INTEGER,     //!< Integral Green Component
	B_INT         = GL_BLUE_INTEGER,      //!< Integral Blue Component
	A_INT         = GL_ALPHA_INTEGER_EXT, //!< Integral Alpha Component
	RGB_INT       = GL_RGB_INTEGER,       //!< Combined Red-Green-Blue
	BGR_INT       = GL_BGR_INTEGER,       //!< Combined Blue-Green-Red
	RGBA_INT      = GL_RGBA_INTEGER,      //!< Combined Red-Green-Blue-Alpha
	BGRA_INT      = GL_BGRA_INTEGER,      //!< Combined Blue-Green-Red-Alpha

	STENCIL       = GL_STENCIL_INDEX,   //!< Stencil Component
	DEPTH         = GL_DEPTH_COMPONENT, //!< Depth Component
	DEPTH_STENCIL = GL_DEPTH_STENCIL,   //!< Combined Depth-Stencil
};


// Pixel Formats =======================================================================================================

///
/// \brief OpenGL Pixel Formats
/// \note UNORM formats are integers interpreted in the normalized range \math{[0.0, 1.0]}
/// \note SNORM formats are integers interpreted in the normalized range \math{[-1.0, 1.0]}
enum pixel_formats : GLint {
	R8_UNORM  = GL_R8,        //!<  8-Bit Unsigned Normalized Single Component Color
	R8_SNORM  = GL_R8_SNORM,  //!<  8-Bit Signed Normalized Single Component Color
	R16_UNORM = GL_R16,       //!< 16-Bit Unsigned Normalized Single Component Color
	R16_SNORM = GL_R16_SNORM, //!< 16-Bit Signed Normalized Single Component Color

	RG8_UNORM  = GL_RG8,        //!<  8-Bit Unsigned Normalized Two Component Color
	RG8_SNORM  = GL_RG8_SNORM,  //!<  8-Bit Signed Normalized Two Component Color
	RG16_UNORM = GL_RG16,       //!< 16-Bit Unsigned Normalized Two Component Color
	RG16_SNORM = GL_RG16_SNORM, //!< 16-Bit Signed Normalized Two Component Color

	RGB4_UNORM   = GL_RGB4,        //!<  4-Bit Unsigned Normalized Three Component Color
	RGB5_UNORM   = GL_RGB5,        //!<  5-Bit Unsigned Normalized Three Component Color
	RGB8_UNORM   = GL_RGB8,        //!<  8-Bit Unsigned Normalized Three Component Color
	RGB8_SNORM   = GL_RGB8_SNORM,  //!<  8-Bit Signed Normalized Three Component Color
	RGB10_UNORM  = GL_RGB10,       //!< 10-Bit Unsigned Normalized Three Component Color
	RGB12_UNORM  = GL_RGB12,       //!< 12-Bit Unsigned Normalized Three Component Color
	RGB16_UNORM  = GL_RGB16,       //!< 16-Bit Unsigned Normalized Three Component Color
	RGB16_SNORM  = GL_RGB16_SNORM, //!< 16-Bit Signed Normalized Three Component Color

	RGB332_UNORM = GL_R3_G3_B2,    //!< Packed 8-Bit Unsigned Normalized Three Component Color

	RGBA2_UNORM  = GL_RGBA2,       //!<  2-Bit Unsigned Normalized Four Component Color
	RGBA4_UNORM  = GL_RGBA4,       //!<  4-Bit Unsigned Normalized Four Component Color
	RGBA8_UNORM  = GL_RGBA8,       //!<  8-Bit Unsigned Normalized Four Component Color
	RGBA8_SNORM  = GL_RGBA8_SNORM, //!<  8-Bit Unsigned Normalized Four Signed Normalized Component Color
	RGBA12_UNORM = GL_RGBA12,      //!< 12-Bit Unsigned Normalized Four Component Color
	RGBA16_UNORM = GL_RGBA16,      //!< 16-Bit Unsigned Normalized Four Component Color

	RGB5_A1_UNORM  = GL_RGB5_A1,     //!< Packed 16-Bit Unsigned Normalized Four Component Color
	RGB10_A2_UNORM = GL_RGB10_A2,    //!< Packed 32-Bit Unsigned Normalized Four Component Color

	SRGB8  = GL_SRGB8,        //!< 8-Bit sRGB Color
	SRGBA8 = GL_SRGB8_ALPHA8, //!< 8-Bit sRGB Color With Linear Alpha

	R16_FLOAT    = GL_R16F,    //!< 16-Bit Floating-Point Single Component Color
	RG16_FLOAT   = GL_RG16F,   //!< 16-Bit Floating-Point Two Component Color
	RGB16_FLOAT  = GL_RGB16F,  //!< 16-Bit Floating-Point Three Component Color
	RGBA16_FLOAT = GL_RGBA16F, //!< 16-Bit Floating-Point Four Component Color

	R32_FLOAT    = GL_R32F,    //!< 32-Bit Floating-Point Single Component Color
	RG32_FLOAT   = GL_RG32F,   //!< 32-Bit Floating-Point Two Component Color
	RGB32_FLOAT  = GL_RGB32F,  //!< 32-Bit Floating-Point Three Component Color
	RGBA32_FLOAT = GL_RGBA32F, //!< 32-Bit Floating-Point Four Component Color

	R8_INT    = GL_R8I,    //!< 8-Bit Integral Single Component Color
	RG8_INT   = GL_RG8I,   //!< 8-Bit Integral Two Component Color
	RGB8_INT  = GL_RGB8I,  //!< 8-Bit Integral Three Component Color
	RGBA8_INT = GL_RGBA8I, //!< 8-Bit Integral Four Component Color

	R16_INT    = GL_R16I,    //!< 16-Bit Integral Single Component Color
	RG16_INT   = GL_RG16I,   //!< 16-Bit Integral Two Component Color
	RGB16_INT  = GL_RGB16I,  //!< 16-Bit Integral Three Component Color
	RGBA16_INT = GL_RGBA16I, //!< 16-Bit Integral Four Component Color

	R32_INT    = GL_R32I,    //!< 32-Bit Integral Single Component Color
	RG32_INT   = GL_RG32I,   //!< 32-Bit Integral Two Component Color
	RGB32_INT  = GL_RGB32I,  //!< 32-Bit Integral Three Component Color
	RGBA32_INT = GL_RGBA32I, //!< 32-Bit Integral Four Component Color

	R8_UINT    = GL_R8UI,    //!< 8-Bit Unsigned Integral Single Component Color
	RG8_UINT   = GL_RG8UI,   //!< 8-Bit Unsigned Integral Two Component Color
	RGB8_UINT  = GL_RGB8UI,  //!< 8-Bit Unsigned Integral Three Component Color
	RGBA8_UINT = GL_RGBA8UI, //!< 8-Bit Unsigned Integral Four Component Color

	R16_UINT      = GL_R16UI,      //!< 16-Bit Unsigned Integral Single Component Color
	RG16_UINT     = GL_RG16UI,     //!< 16-Bit Unsigned Integral Two Component Color
	RGB16_UINT    = GL_RGB16UI,    //!< 16-Bit Unsigned Integral Three Component Color
	RGBA16_UINT   = GL_RGBA16UI,   //!< 16-Bit Unsigned Integral Four Component Color
	RGB10_A2_UINT = GL_RGB10_A2UI, //!< Packed 32-Bit Unsigned Integral Four Component Color

	R32UI    = GL_R32UI,    //!< 32-Bit Unsigned Integral Single Component Color
	RG32UI   = GL_RG32UI,   //!< 32-Bit Unsigned Integral Two Component Color
	RGB32UI  = GL_RGB32UI,  //!< 32-Bit Unsigned Integral Three Component Color
	RGBA32UI = GL_RGBA32UI, //!< 32-Bit Unsigned Integral Four Component Color

	RGB_DXT1  = GL_COMPRESSED_RGB_S3TC_DXT1_EXT,  //!< Compressed RGB DXT1 Color
	RGBA_DXT1 = GL_COMPRESSED_RGBA_S3TC_DXT1_EXT, //!< Compressed RGBA DXT1 Color
	RGBA_DXT3 = GL_COMPRESSED_RGBA_S3TC_DXT3_EXT, //!< Compressed RGBA DXT3 Color
	RGBA_DXT5 = GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, //!< Compressed RGBA DXT5 Color

	SRGB_DXT1  = GL_COMPRESSED_SRGB_S3TC_DXT1_EXT,       //!< Compressed sRGB  DXT1 Color
	SRGBA_DXT1 = GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT, //!< Compressed sRGBA DXT1 Color
	SRGBA_DXT3 = GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT, //!< Compressed sRGBA DXT3 Color
	SRGBA_DXT5 = GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT, //!< Compressed sRGBA DXT5 Color
};


// Framebuffer Attachments =============================================================================================


///
/// \brief OpenGL Framebuffer Attachments
enum framebuffer_attachments {
	NO_ATTACHMENT            = GL_NONE,                     //!< No Attachment
	DEPTH_ATTACHMENT         = GL_DEPTH_ATTACHMENT,         //!< Depth Attachment
	STENCIL_ATTACHMENT       = GL_STENCIL_ATTACHMENT,       //!< Stencil Attachment
	DEPTH_STENCIL_ATTACHMENT = GL_DEPTH_STENCIL_ATTACHMENT, //!< Depth Stencil Attachment
	COLOR_ATTACHMENT         = GL_COLOR_ATTACHMENT0,        //!< Color Attachment
};

}

}

#endif // FENNEC_RENDERERS_OPENGL_LIB_ENUM_H
