diff --git a/engine/include/XCEngine/RHI/OpenGL/OpenGLEnums.h b/engine/include/XCEngine/RHI/OpenGL/OpenGLEnums.h new file mode 100644 index 00000000..54d3806a --- /dev/null +++ b/engine/include/XCEngine/RHI/OpenGL/OpenGLEnums.h @@ -0,0 +1,290 @@ +#pragma once + +#include +#include "../RHIEnums.h" +#include "../RHITypes.h" +#include "OpenGLTexture.h" +#include "OpenGLBuffer.h" +#include "OpenGLVertexArray.h" +#include "OpenGLRenderTargetView.h" +#include "OpenGLSampler.h" +#include "OpenGLCommandList.h" + +namespace XCEngine { +namespace RHI { + +inline GLenum ToOpenGL(PrimitiveTopology topology) { + switch (topology) { + case PrimitiveTopology::PointList: return GL_POINTS; + case PrimitiveTopology::LineList: return GL_LINES; + case PrimitiveTopology::LineStrip: return GL_LINE_STRIP; + case PrimitiveTopology::TriangleList: return GL_TRIANGLES; + case PrimitiveTopology::TriangleStrip: return GL_TRIANGLE_STRIP; + case PrimitiveTopology::LineListAdj: return GL_LINES_ADJACENCY; + case PrimitiveTopology::LineStripAdj: return GL_LINE_STRIP_ADJACENCY; + case PrimitiveTopology::TriangleListAdj: return GL_TRIANGLES_ADJACENCY; + case PrimitiveTopology::TriangleStripAdj: return GL_TRIANGLE_STRIP_ADJACENCY; + case PrimitiveTopology::PatchList: return GL_PATCHES; + default: return GL_TRIANGLES; + } +} + +inline GLenum ToOpenGL(PrimitiveType type) { + switch (type) { + case PrimitiveType::Points: return GL_POINTS; + case PrimitiveType::Lines: return GL_LINES; + case PrimitiveType::LineStrip: return GL_LINE_STRIP; + case PrimitiveType::Triangles: return GL_TRIANGLES; + case PrimitiveType::TriangleStrip: return GL_TRIANGLE_STRIP; + case PrimitiveType::TriangleFan: return GL_TRIANGLE_FAN; + case PrimitiveType::LineListAdj: return GL_LINES_ADJACENCY; + case PrimitiveType::TriangleListAdj: return GL_TRIANGLES_ADJACENCY; + case PrimitiveType::Patch: return GL_PATCHES; + default: return GL_TRIANGLES; + } +} + +inline GLenum ToOpenGL(ComparisonFunc func) { + switch (func) { + case ComparisonFunc::Never: return GL_NEVER; + case ComparisonFunc::Less: return GL_LESS; + case ComparisonFunc::Equal: return GL_EQUAL; + case ComparisonFunc::LessEqual: return GL_LEQUAL; + case ComparisonFunc::Greater: return GL_GREATER; + case ComparisonFunc::NotEqual: return GL_NOTEQUAL; + case ComparisonFunc::GreaterEqual: return GL_GEQUAL; + case ComparisonFunc::Always: return GL_ALWAYS; + default: return GL_LESS; + } +} + +inline GLenum ToOpenGL(StencilOp op) { + switch (op) { + case StencilOp::Keep: return GL_KEEP; + case StencilOp::Zero: return GL_ZERO; + case StencilOp::Replace: return GL_REPLACE; + case StencilOp::IncrSat: return GL_INCR; + case StencilOp::DecrSat: return GL_DECR; + case StencilOp::Invert: return GL_INVERT; + case StencilOp::Incr: return GL_INCR_WRAP; + case StencilOp::Decr: return GL_DECR_WRAP; + default: return GL_KEEP; + } +} + +inline GLenum ToOpenGL(BlendFactor factor) { + switch (factor) { + case BlendFactor::Zero: return GL_ZERO; + case BlendFactor::One: return GL_ONE; + case BlendFactor::SrcColor: return GL_SRC_COLOR; + case BlendFactor::InvSrcColor: return GL_ONE_MINUS_SRC_COLOR; + case BlendFactor::SrcAlpha: return GL_SRC_ALPHA; + case BlendFactor::InvSrcAlpha: return GL_ONE_MINUS_SRC_ALPHA; + case BlendFactor::DstAlpha: return GL_DST_ALPHA; + case BlendFactor::InvDstAlpha: return GL_ONE_MINUS_DST_ALPHA; + case BlendFactor::DstColor: return GL_DST_COLOR; + case BlendFactor::InvDstColor: return GL_ONE_MINUS_DST_COLOR; + case BlendFactor::SrcAlphaSat: return GL_SRC_ALPHA_SATURATE; + case BlendFactor::BlendFactor: return GL_CONSTANT_COLOR; + case BlendFactor::InvBlendFactor: return GL_ONE_MINUS_CONSTANT_COLOR; + case BlendFactor::Src1Color: return GL_SRC1_COLOR; + case BlendFactor::InvSrc1Color: return GL_ONE_MINUS_SRC1_COLOR; + case BlendFactor::Src1Alpha: return GL_SRC1_ALPHA; + case BlendFactor::InvSrc1Alpha: return GL_ONE_MINUS_SRC1_ALPHA; + default: return GL_ONE; + } +} + +inline GLenum ToOpenGL(BlendOp op) { + switch (op) { + case BlendOp::Add: return GL_FUNC_ADD; + case BlendOp::Subtract: return GL_FUNC_SUBTRACT; + case BlendOp::ReverseSubtract: return GL_FUNC_REVERSE_SUBTRACT; + case BlendOp::Min: return GL_MIN; + case BlendOp::Max: return GL_MAX; + default: return GL_FUNC_ADD; + } +} + +inline GLenum ToOpenGL(OpenGLTextureType type) { + switch (type) { + case OpenGLTextureType::Texture1D: return GL_TEXTURE_1D; + case OpenGLTextureType::Texture2D: return GL_TEXTURE_2D; + case OpenGLTextureType::Texture2DArray: return GL_TEXTURE_2D_ARRAY; + case OpenGLTextureType::Texture3D: return GL_TEXTURE_3D; + case OpenGLTextureType::TextureCube: return GL_TEXTURE_CUBE_MAP; + case OpenGLTextureType::TextureCubeArray: return GL_TEXTURE_CUBE_MAP_ARRAY; + default: return GL_TEXTURE_2D; + } +} + +inline void ToOpenGLFormat(OpenGLFormat fmt, GLint& internalFormat, GLenum& glFormat, GLenum& glType) { + switch (fmt) { + case OpenGLFormat::R8: + internalFormat = GL_R8; glFormat = GL_RED; glType = GL_UNSIGNED_BYTE; + break; + case OpenGLFormat::RG8: + internalFormat = GL_RG8; glFormat = GL_RG; glType = GL_UNSIGNED_BYTE; + break; + case OpenGLFormat::RGBA8: + internalFormat = GL_RGBA8; glFormat = GL_RGBA; glType = GL_UNSIGNED_BYTE; + break; + case OpenGLFormat::RGBA16F: + internalFormat = GL_RGBA16F; glFormat = GL_RGBA; glType = GL_HALF_FLOAT; + break; + case OpenGLFormat::RGBA32F: + internalFormat = GL_RGBA32F; glFormat = GL_RGBA; glType = GL_FLOAT; + break; + case OpenGLFormat::Depth24Stencil8: + internalFormat = GL_DEPTH24_STENCIL8; glFormat = GL_DEPTH_STENCIL; glType = GL_UNSIGNED_INT_24_8; + break; + case OpenGLFormat::Depth32F: + internalFormat = GL_DEPTH_COMPONENT32F; glFormat = GL_DEPTH_COMPONENT; glType = GL_FLOAT; + break; + default: + internalFormat = GL_RGBA8; glFormat = GL_RGBA; glType = GL_UNSIGNED_BYTE; + break; + } +} + +inline GLenum ToOpenGL(OpenGLBufferType type) { + switch (type) { + case OpenGLBufferType::Vertex: return GL_ARRAY_BUFFER; + case OpenGLBufferType::Index: return GL_ELEMENT_ARRAY_BUFFER; + case OpenGLBufferType::Uniform: return GL_UNIFORM_BUFFER; + case OpenGLBufferType::CopyRead: return GL_COPY_READ_BUFFER; + case OpenGLBufferType::CopyWrite: return GL_COPY_WRITE_BUFFER; + case OpenGLBufferType::AtomicCounter: return GL_ATOMIC_COUNTER_BUFFER; + case OpenGLBufferType::DispatchIndirect: return GL_DISPATCH_INDIRECT_BUFFER; + case OpenGLBufferType::DrawIndirect: return GL_DRAW_INDIRECT_BUFFER; + case OpenGLBufferType::ShaderBindingTable: return GL_SHADER_STORAGE_BUFFER; + default: return GL_ARRAY_BUFFER; + } +} + +inline GLenum ToOpenGL(VertexAttributeType type) { + switch (type) { + case VertexAttributeType::Float: return GL_FLOAT; + case VertexAttributeType::Int: return GL_INT; + case VertexAttributeType::UnsignedInt: return GL_UNSIGNED_INT; + case VertexAttributeType::Short: return GL_SHORT; + case VertexAttributeType::UnsignedShort: return GL_UNSIGNED_SHORT; + case VertexAttributeType::Byte: return GL_BYTE; + case VertexAttributeType::UnsignedByte: return GL_UNSIGNED_BYTE; + case VertexAttributeType::Double: return GL_DOUBLE; + case VertexAttributeType::HalfFloat: return GL_HALF_FLOAT; + case VertexAttributeType::Fixed: return GL_FIXED; + case VertexAttributeType::Int2101010Rev: return GL_INT_2_10_10_10_REV; + case VertexAttributeType::UnsignedInt2101010Rev: return GL_UNSIGNED_INT_2_10_10_10_REV; + case VertexAttributeType::UnsignedInt10F11F11FRev: return GL_UNSIGNED_INT_10F_11F_11F_REV; + default: return GL_FLOAT; + } +} + +inline GLenum ToOpenGL(RenderTargetType type) { + switch (type) { + case RenderTargetType::Texture2D: return GL_TEXTURE_2D; + case RenderTargetType::Texture2DArray: return GL_TEXTURE_2D_ARRAY; + case RenderTargetType::Texture3D: return GL_TEXTURE_3D; + case RenderTargetType::TextureCube: return GL_TEXTURE_CUBE_MAP; + case RenderTargetType::TextureCubeArray: return GL_TEXTURE_CUBE_MAP_ARRAY; + default: return GL_TEXTURE_2D; + } +} + +inline GLenum ToOpenGL(SamplerWrapMode mode) { + switch (mode) { + case SamplerWrapMode::Repeat: return GL_REPEAT; + case SamplerWrapMode::MirroredRepeat: return GL_MIRRORED_REPEAT; + case SamplerWrapMode::ClampToEdge: return GL_CLAMP_TO_EDGE; + case SamplerWrapMode::ClampToBorder: return GL_CLAMP_TO_BORDER; + default: return GL_REPEAT; + } +} + +inline GLenum ToOpenGL(SamplerFilter filter) { + switch (filter) { + case SamplerFilter::Nearest: return GL_NEAREST; + case SamplerFilter::Linear: return GL_LINEAR; + case SamplerFilter::NearestMipmapNearest: return GL_NEAREST_MIPMAP_NEAREST; + case SamplerFilter::LinearMipmapNearest: return GL_LINEAR_MIPMAP_NEAREST; + case SamplerFilter::NearestMipmapLinear: return GL_NEAREST_MIPMAP_LINEAR; + case SamplerFilter::LinearMipmapLinear: return GL_LINEAR_MIPMAP_LINEAR; + default: return GL_LINEAR; + } +} + +inline GLenum ToOpenGL(TextureAddressMode mode) { + switch (mode) { + case TextureAddressMode::Wrap: return GL_REPEAT; + case TextureAddressMode::Mirror: return GL_MIRRORED_REPEAT; + case TextureAddressMode::Clamp: return GL_CLAMP_TO_EDGE; + case TextureAddressMode::Border: return GL_CLAMP_TO_BORDER; + case TextureAddressMode::MirrorOnce: return GL_MIRROR_CLAMP_TO_EDGE; + default: return GL_REPEAT; + } +} + +inline GLenum ToOpenGL(FilterMode mode) { + switch (mode) { + case FilterMode::Point: return GL_NEAREST; + case FilterMode::Linear: return GL_LINEAR; + case FilterMode::Anisotropic: return GL_LINEAR; + case FilterMode::ComparisonPoint: return GL_NEAREST; + case FilterMode::ComparisonLinear: return GL_LINEAR; + case FilterMode::ComparisonAnisotropic: return GL_LINEAR; + default: return GL_LINEAR; + } +} + +inline GLenum ToOpenGL(CullMode mode) { + switch (mode) { + case CullMode::None: return 0; + case CullMode::Front: return GL_FRONT; + case CullMode::Back: return GL_BACK; + default: return GL_BACK; + } +} + +inline GLenum ToOpenGL(FrontFace face) { + switch (face) { + case FrontFace::Clockwise: return GL_CW; + case FrontFace::CounterClockwise: return GL_CCW; + default: return GL_CCW; + } +} + +inline GLenum ToOpenGL(FillMode mode) { + switch (mode) { + case FillMode::Wireframe: return GL_LINE; + case FillMode::Solid: return GL_FILL; + default: return GL_FILL; + } +} + +inline GLbitfield ToOpenGLClearBuffer(uint32_t buffers) { + GLbitfield glBuffers = 0; + if (buffers & 1) glBuffers |= GL_COLOR_BUFFER_BIT; + if (buffers & 2) glBuffers |= GL_DEPTH_BUFFER_BIT; + if (buffers & 4) glBuffers |= GL_STENCIL_BUFFER_BIT; + return glBuffers; +} + +inline GLenum ToOpenGLDepthAttachment() { + return GL_DEPTH_ATTACHMENT; +} + +inline GLenum ToOpenGLStencilAttachment() { + return GL_STENCIL_ATTACHMENT; +} + +inline GLenum ToOpenGLDepthStencilAttachment() { + return GL_DEPTH_STENCIL_ATTACHMENT; +} + +inline GLenum ToOpenGLColorAttachment(uint32_t index) { + return GL_COLOR_ATTACHMENT0 + index; +} + +} // namespace RHI +} // namespace XCEngine