xuanchi/XCEngine
1
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

refactor: Refactor OpenGL backend to use OpenGLEnums

Browse Source 
Use centralized OpenGLEnums.h for enum conversion:
- Remove local ToGL* functions from OpenGLCommandList
- Replace with ToOpenGL() and ToOpenGLClearBuffer() from OpenGLEnums
- Simplify OpenGLTexture, OpenGLBuffer, OpenGLSampler, etc.
This commit is contained in:
ssdfasd
2026-03-25 19:01:36 +08:00
parent 773d1aa38a
commit 712e975610
13 changed files with 108 additions and 297 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
engine/include/XCEngine/RHI/OpenGL/OpenGLDevice.h
View File

@@ -39,7 +39,7 @@ public:
RHISwapChain* CreateSwapChain(const SwapChainDesc& desc) override;
RHICommandList* CreateCommandList(const CommandListDesc& desc) override;
RHICommandQueue* CreateCommandQueue(const CommandQueueDesc& desc) override;
RHIShader* CompileShader(const ShaderCompileDesc& desc) override;
RHIShader* CreateShader(const ShaderCompileDesc& desc) override;
RHIPipelineState* CreatePipelineState(const GraphicsPipelineDesc& desc) override;
RHIPipelineLayout* CreatePipelineLayout(const RHIPipelineLayoutDesc& desc) override;
RHIFence* CreateFence(const FenceDesc& desc) override;

9
engine/include/XCEngine/RHI/OpenGL/OpenGLScreenshot.h
View File

@@ -2,6 +2,7 @@
#include <cstdint>
#include <string>
#include "../RHIScreenshot.h"
namespace XCEngine {
namespace RHI {
@@ -9,8 +10,11 @@ namespace RHI {
class OpenGLSwapChain;
class OpenGLDevice;
class OpenGLScreenshot {
class OpenGLScreenshot : public RHIScreenshot {
public:
bool Capture(RHIDevice* device, RHISwapChain* swapChain, const char* filename) override;
void Shutdown() override {}
static bool Capture(OpenGLDevice& device,
OpenGLSwapChain& swapChain,
const char* filename);
@@ -23,7 +27,8 @@ public:
private:
static bool SavePPM(const char* filename,
int width, int height);
int width,
int height);
};
} // namespace RHI

28
engine/src/RHI/OpenGL/OpenGLBuffer.cpp
View File

@@ -1,24 +1,10 @@
#include "XCEngine/RHI/OpenGL/OpenGLBuffer.h"
#include "XCEngine/RHI/OpenGL/OpenGLEnums.h"
#include <glad/glad.h>
namespace XCEngine {
namespace RHI {
static unsigned int ToGLBufferTarget(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;
}
}
OpenGLBuffer::OpenGLBuffer()
: m_buffer(0)
, m_size(0)
@@ -37,7 +23,7 @@ bool OpenGLBuffer::Initialize(OpenGLBufferType type, size_t size, const void* da
m_dynamic = dynamic;
m_isIndexBuffer = (type == OpenGLBufferType::Index);
unsigned int target = ToGLBufferTarget(type);
unsigned int target = ToOpenGL(type);
GLenum usage = dynamic ? GL_DYNAMIC_DRAW : GL_STATIC_DRAW;
glGenBuffers(1, &m_buffer);
@@ -64,12 +50,12 @@ void OpenGLBuffer::Shutdown() {
}
void OpenGLBuffer::Bind() const {
unsigned int target = ToGLBufferTarget(m_type);
unsigned int target = ToOpenGL(m_type);
glBindBuffer(target, m_buffer);
}
void OpenGLBuffer::Unbind() const {
unsigned int target = ToGLBufferTarget(m_type);
unsigned int target = ToOpenGL(m_type);
glBindBuffer(target, 0);
}
@@ -78,7 +64,7 @@ void OpenGLBuffer::BindBase(unsigned int target, unsigned int index) const {
}
void* OpenGLBuffer::Map() {
unsigned int target = ToGLBufferTarget(m_type);
unsigned int target = ToOpenGL(m_type);
glBindBuffer(target, m_buffer);
void* ptr = glMapBuffer(target, GL_WRITE_ONLY);
glBindBuffer(target, 0);
@@ -86,14 +72,14 @@ void* OpenGLBuffer::Map() {
}
void OpenGLBuffer::Unmap() {
unsigned int target = ToGLBufferTarget(m_type);
unsigned int target = ToOpenGL(m_type);
glBindBuffer(target, m_buffer);
glUnmapBuffer(target);
glBindBuffer(target, 0);
}
void OpenGLBuffer::SetData(const void* data, size_t size, size_t offset) {
unsigned int target = ToGLBufferTarget(m_type);
unsigned int target = ToOpenGL(m_type);
glBindBuffer(target, m_buffer);
if (offset == 0 && size == m_size) {
glBufferData(target, size, data, m_dynamic ? GL_DYNAMIC_DRAW : GL_STATIC_DRAW);

122
engine/src/RHI/OpenGL/OpenGLCommandList.cpp
View File

@@ -5,26 +5,12 @@
#include "XCEngine/RHI/OpenGL/OpenGLFramebuffer.h"
#include "XCEngine/RHI/OpenGL/OpenGLRenderPass.h"
#include "XCEngine/RHI/OpenGL/OpenGLDescriptorSet.h"
#include "XCEngine/RHI/OpenGL/OpenGLEnums.h"
#include <glad/glad.h>
namespace XCEngine {
namespace RHI {
static unsigned int ToGLPrimitiveType(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;
}
}
OpenGLCommandList::OpenGLCommandList()
: m_primitiveType(GL_TRIANGLES)
, m_currentVAO(0)
@@ -37,11 +23,7 @@ OpenGLCommandList::~OpenGLCommandList() {
void OpenGLCommandList::Clear(float r, float g, float b, float a, unsigned int buffers) {
glClearColor(r, g, b, a);
unsigned int 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;
glClear(glBuffers);
glClear(ToOpenGLClearBuffer(buffers));
}
void OpenGLCommandList::ClearColor(float r, float g, float b, float a) {
@@ -206,35 +188,35 @@ void OpenGLCommandList::SetPolygonOffset(float factor, float units) {
}
void OpenGLCommandList::SetPrimitiveType(PrimitiveType type) {
m_primitiveType = ToGLPrimitiveType(type);
m_primitiveType = ToOpenGL(type);
}
void OpenGLCommandList::Draw(PrimitiveType type, unsigned int vertexCount, unsigned int startVertex) {
m_primitiveType = ToGLPrimitiveType(type);
m_primitiveType = ToOpenGL(type);
glDrawArrays(m_primitiveType, startVertex, vertexCount);
}
void OpenGLCommandList::DrawInstanced(PrimitiveType type, unsigned int vertexCount, unsigned int instanceCount, unsigned int startVertex, unsigned int startInstance) {
m_primitiveType = ToGLPrimitiveType(type);
m_primitiveType = ToOpenGL(type);
glDrawArraysInstanced(m_primitiveType, startVertex, vertexCount, instanceCount);
(void)startInstance;
}
void OpenGLCommandList::DrawIndexed(PrimitiveType type, unsigned int indexCount, unsigned int startIndex, int baseVertex) {
m_primitiveType = ToGLPrimitiveType(type);
m_primitiveType = ToOpenGL(type);
glDrawElements(m_primitiveType, indexCount, GL_UNSIGNED_INT, (void*)(startIndex * sizeof(unsigned int)));
(void)baseVertex;
}
void OpenGLCommandList::DrawIndexedInstanced(PrimitiveType type, unsigned int indexCount, unsigned int instanceCount, unsigned int startIndex, int baseVertex, unsigned int startInstance) {
m_primitiveType = ToGLPrimitiveType(type);
m_primitiveType = ToOpenGL(type);
glDrawElementsInstanced(m_primitiveType, indexCount, GL_UNSIGNED_INT, (void*)(startIndex * sizeof(unsigned int)), instanceCount);
(void)baseVertex;
(void)startInstance;
}
void OpenGLCommandList::DrawIndirect(PrimitiveType type, unsigned int buffer, size_t offset, unsigned int drawCount, unsigned int stride) {
m_primitiveType = ToGLPrimitiveType(type);
m_primitiveType = ToOpenGL(type);
glBindBuffer(GL_DRAW_INDIRECT_BUFFER, buffer);
glDrawArraysIndirect(m_primitiveType, (void*)offset);
glBindBuffer(GL_DRAW_INDIRECT_BUFFER, 0);
@@ -243,7 +225,7 @@ void OpenGLCommandList::DrawIndirect(PrimitiveType type, unsigned int buffer, si
}
void OpenGLCommandList::DrawIndexedIndirect(PrimitiveType type, unsigned int buffer, size_t offset, unsigned int drawCount, unsigned int stride) {
m_primitiveType = ToGLPrimitiveType(type);
m_primitiveType = ToOpenGL(type);
glBindBuffer(GL_DRAW_INDIRECT_BUFFER, buffer);
glDrawElementsIndirect(m_primitiveType, GL_UNSIGNED_INT, (void*)offset);
glBindBuffer(GL_DRAW_INDIRECT_BUFFER, 0);
@@ -252,12 +234,12 @@ void OpenGLCommandList::DrawIndexedIndirect(PrimitiveType type, unsigned int buf
}
void OpenGLCommandList::MultiDrawArrays(PrimitiveType type, const int* first, const int* count, unsigned int drawCount) {
m_primitiveType = ToGLPrimitiveType(type);
m_primitiveType = ToOpenGL(type);
glMultiDrawArrays(m_primitiveType, first, count, drawCount);
}
void OpenGLCommandList::MultiDrawElements(PrimitiveType type, const int* count, unsigned int type_, const void* const* indices, unsigned int drawCount) {
m_primitiveType = ToGLPrimitiveType(type);
m_primitiveType = ToOpenGL(type);
glMultiDrawElements(m_primitiveType, count, type_, indices, drawCount);
}
@@ -566,7 +548,7 @@ void OpenGLCommandList::SetRenderTargets(uint32_t count, RHIResourceView** rende
std::vector<GLenum> drawBuffers(count);
for (uint32_t i = 0; i < count; ++i) {
drawBuffers[i] = GL_COLOR_ATTACHMENT0 + i;
drawBuffers[i] = ToOpenGLColorAttachment(i);
}
glDrawBuffers(count, drawBuffers.data());
@@ -700,86 +682,8 @@ void OpenGLCommandList::DrawIndexed(uint32_t indexCount, uint32_t instanceCount,
reinterpret_cast<const void*>(startIndex * sizeof(GLuint)), static_cast<GLsizei>(instanceCount));
}
static unsigned int ToGLPrimitiveTopology(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;
}
}
static unsigned int ToGLComparisonFunc(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;
}
}
static unsigned int ToGLStencilOp(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;
}
}
static unsigned int ToGLBlendFactor(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;
}
}
static unsigned int ToGLBlendOp(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;
}
}
void OpenGLCommandList::SetPrimitiveTopology(PrimitiveTopology topology) {
m_primitiveType = ToGLPrimitiveTopology(topology);
m_primitiveType = ToOpenGL(topology);
}
void OpenGLCommandList::SetStencilRef(uint8_t ref) {

12
engine/src/RHI/OpenGL/OpenGLDepthStencilView.cpp
View File

@@ -1,4 +1,5 @@
#include "XCEngine/RHI/OpenGL/OpenGLDepthStencilView.h"
#include "XCEngine/RHI/OpenGL/OpenGLEnums.h"
#include <glad/glad.h>
namespace XCEngine {
@@ -26,18 +27,15 @@ bool OpenGLDepthStencilView::Initialize(unsigned int texture, const OpenGLDepthS
glGenFramebuffers(1, &m_framebuffer);
glBindFramebuffer(GL_FRAMEBUFFER, m_framebuffer);
GLenum depthAttachment = GL_DEPTH_ATTACHMENT;
GLenum stencilAttachment = GL_STENCIL_ATTACHMENT;
switch (desc.type) {
case DepthStencilType::Texture2D:
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, texture, desc.mipLevel);
glFramebufferTexture2D(GL_FRAMEBUFFER, ToOpenGLDepthAttachment(), GL_TEXTURE_2D, texture, desc.mipLevel);
break;
case DepthStencilType::Texture2DArray:
glFramebufferTextureLayer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, texture, desc.mipLevel, desc.baseArraySlice);
glFramebufferTextureLayer(GL_FRAMEBUFFER, ToOpenGLDepthAttachment(), texture, desc.mipLevel, desc.baseArraySlice);
break;
case DepthStencilType::TextureCube:
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_CUBE_MAP_POSITIVE_X + desc.baseArraySlice, texture, desc.mipLevel);
glFramebufferTexture2D(GL_FRAMEBUFFER, ToOpenGLDepthAttachment(), GL_TEXTURE_CUBE_MAP_POSITIVE_X + desc.baseArraySlice, texture, desc.mipLevel);
break;
}
@@ -63,7 +61,7 @@ bool OpenGLDepthStencilView::InitializeCubemap(unsigned int cubemap, int face, i
glGenFramebuffers(1, &m_framebuffer);
glBindFramebuffer(GL_FRAMEBUFFER, m_framebuffer);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_CUBE_MAP_POSITIVE_X + face, cubemap, mipLevel);
glFramebufferTexture2D(GL_FRAMEBUFFER, ToOpenGLDepthAttachment(), GL_TEXTURE_CUBE_MAP_POSITIVE_X + face, cubemap, mipLevel);
if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) {
glBindFramebuffer(GL_FRAMEBUFFER, 0);

2
engine/src/RHI/OpenGL/OpenGLDevice.cpp
View File

@@ -353,7 +353,7 @@ RHICommandQueue* OpenGLDevice::CreateCommandQueue(const CommandQueueDesc& desc)
return queue;
}
RHIShader* OpenGLDevice::CompileShader(const ShaderCompileDesc& desc) {
RHIShader* OpenGLDevice::CreateShader(const ShaderCompileDesc& desc) {
auto* shader = new OpenGLShader();
if (desc.sourceLanguage == ShaderLanguage::GLSL && !desc.source.empty()) {

18
engine/src/RHI/OpenGL/OpenGLFramebuffer.cpp
View File

@@ -1,5 +1,6 @@
#include "XCEngine/RHI/OpenGL/OpenGLFramebuffer.h"
#include "XCEngine/RHI/OpenGL/OpenGLResourceView.h"
#include "XCEngine/RHI/OpenGL/OpenGLEnums.h"
#include <glad/glad.h>
namespace XCEngine {
@@ -30,7 +31,7 @@ bool OpenGLFramebuffer::Initialize(const FramebufferDesc& desc) {
for (size_t i = 0; i < desc.colorAttachments.size() && i < 16; ++i) {
const auto& attachment = desc.colorAttachments[i];
GLenum glAttachment = GL_COLOR_ATTACHMENT0 + static_cast<GLenum>(i);
GLenum glAttachment = ToOpenGLColorAttachment(static_cast<uint32_t>(i));
switch (attachment.type) {
case FramebufferAttachmentType::Color:
@@ -47,9 +48,9 @@ bool OpenGLFramebuffer::Initialize(const FramebufferDesc& desc) {
}
if (desc.depthAttachment.texture != 0) {
GLenum depthAttachment = GL_DEPTH_ATTACHMENT;
GLenum depthAttachment = ToOpenGLDepthAttachment();
if (desc.stencilAttachment.texture != 0) {
depthAttachment = GL_DEPTH_STENCIL_ATTACHMENT;
depthAttachment = ToOpenGLDepthStencilAttachment();
}
if (desc.depthAttachment.layer == 0 && desc.depthAttachment.mipLevel == 0) {
@@ -62,12 +63,13 @@ bool OpenGLFramebuffer::Initialize(const FramebufferDesc& desc) {
}
if (desc.stencilAttachment.texture != 0 && desc.stencilAttachment.texture != desc.depthAttachment.texture) {
GLenum stencilAttachment = ToOpenGLStencilAttachment();
if (desc.stencilAttachment.layer == 0 && desc.stencilAttachment.mipLevel == 0) {
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_TEXTURE_2D, desc.stencilAttachment.texture, 0);
glFramebufferTexture2D(GL_FRAMEBUFFER, stencilAttachment, GL_TEXTURE_2D, desc.stencilAttachment.texture, 0);
} else if (desc.stencilAttachment.layer > 0) {
glFramebufferTextureLayer(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, desc.stencilAttachment.texture, desc.stencilAttachment.mipLevel, desc.stencilAttachment.layer);
glFramebufferTextureLayer(GL_FRAMEBUFFER, stencilAttachment, desc.stencilAttachment.texture, desc.stencilAttachment.mipLevel, desc.stencilAttachment.layer);
} else {
glFramebufferTexture(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, desc.stencilAttachment.texture, desc.stencilAttachment.mipLevel);
glFramebufferTexture(GL_FRAMEBUFFER, stencilAttachment, desc.stencilAttachment.texture, desc.stencilAttachment.mipLevel);
}
}
@@ -115,7 +117,7 @@ bool OpenGLFramebuffer::Initialize(class RHIRenderPass* renderPass, uint32_t wid
for (uint32_t i = 0; i < colorAttachmentCount && i < 16; ++i) {
if (colorAttachments[i]) {
OpenGLResourceView* view = static_cast<OpenGLResourceView*>(colorAttachments[i]);
GLenum glAttachment = GL_COLOR_ATTACHMENT0 + static_cast<GLenum>(i);
GLenum glAttachment = ToOpenGLColorAttachment(i);
unsigned int texture = view->GetTexture();
if (texture) {
glFramebufferTexture2D(GL_FRAMEBUFFER, glAttachment, GL_TEXTURE_2D, texture, 0);
@@ -128,7 +130,7 @@ bool OpenGLFramebuffer::Initialize(class RHIRenderPass* renderPass, uint32_t wid
OpenGLResourceView* view = static_cast<OpenGLResourceView*>(depthStencilAttachment);
unsigned int texture = view->GetTexture();
if (texture) {
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_TEXTURE_2D, texture, 0);
glFramebufferTexture2D(GL_FRAMEBUFFER, ToOpenGLDepthStencilAttachment(), GL_TEXTURE_2D, texture, 0);
}
}

35
engine/src/RHI/OpenGL/OpenGLPipelineState.cpp
View File

@@ -1,5 +1,6 @@
#include "XCEngine/RHI/OpenGL/OpenGLPipelineState.h"
#include "XCEngine/RHI/OpenGL/OpenGLShader.h"
#include "XCEngine/RHI/OpenGL/OpenGLEnums.h"
#include <glad/glad.h>
namespace XCEngine {
@@ -86,20 +87,20 @@ void OpenGLPipelineState::ApplyDepthStencil() {
glDisable(GL_DEPTH_TEST);
}
glDepthMask(m_glDepthStencilState.depthWriteEnable ? GL_TRUE : GL_FALSE);
glDepthFunc(static_cast<GLenum>(m_glDepthStencilState.depthFunc));
glDepthFunc(ToOpenGL(m_glDepthStencilState.depthFunc));
if (m_glDepthStencilState.stencilEnable) {
glEnable(GL_STENCIL_TEST);
glStencilMask(m_glDepthStencilState.stencilWriteMask);
glStencilFunc(
static_cast<GLenum>(m_glDepthStencilState.stencilFunc),
ToOpenGL(m_glDepthStencilState.stencilFunc),
m_glDepthStencilState.stencilRef,
m_glDepthStencilState.stencilReadMask
);
glStencilOp(
static_cast<GLenum>(m_glDepthStencilState.stencilFailOp),
static_cast<GLenum>(m_glDepthStencilState.stencilDepthFailOp),
static_cast<GLenum>(m_glDepthStencilState.stencilDepthPassOp)
ToOpenGL(m_glDepthStencilState.stencilFailOp),
ToOpenGL(m_glDepthStencilState.stencilDepthFailOp),
ToOpenGL(m_glDepthStencilState.stencilDepthPassOp)
);
} else {
glDisable(GL_STENCIL_TEST);
@@ -110,14 +111,14 @@ void OpenGLPipelineState::ApplyBlend() {
if (m_glBlendState.blendEnable) {
glEnable(GL_BLEND);
glBlendFuncSeparate(
static_cast<GLenum>(m_glBlendState.srcBlend),
static_cast<GLenum>(m_glBlendState.dstBlend),
static_cast<GLenum>(m_glBlendState.srcBlendAlpha),
static_cast<GLenum>(m_glBlendState.dstBlendAlpha)
ToOpenGL(m_glBlendState.srcBlend),
ToOpenGL(m_glBlendState.dstBlend),
ToOpenGL(m_glBlendState.srcBlendAlpha),
ToOpenGL(m_glBlendState.dstBlendAlpha)
);
glBlendEquationSeparate(
static_cast<GLenum>(m_glBlendState.blendOp),
static_cast<GLenum>(m_glBlendState.blendOpAlpha)
ToOpenGL(m_glBlendState.blendOp),
ToOpenGL(m_glBlendState.blendOpAlpha)
);
glColorMask(
(m_glBlendState.colorWriteMask & 1) != 0,
@@ -133,13 +134,13 @@ void OpenGLPipelineState::ApplyBlend() {
void OpenGLPipelineState::ApplyRasterizer() {
if (m_glRasterizerState.cullFaceEnable) {
glEnable(GL_CULL_FACE);
glCullFace(static_cast<GLenum>(m_glRasterizerState.cullFace));
glFrontFace(static_cast<GLenum>(m_glRasterizerState.frontFace));
glCullFace(ToOpenGL(m_glRasterizerState.cullFace));
glFrontFace(ToOpenGL(m_glRasterizerState.frontFace));
} else {
glDisable(GL_CULL_FACE);
}
glPolygonMode(GL_FRONT_AND_BACK, static_cast<GLenum>(m_glRasterizerState.polygonMode));
glPolygonMode(GL_FRONT_AND_BACK, ToOpenGL(m_glRasterizerState.polygonMode));
if (m_glRasterizerState.multisampleEnable) {
glEnable(GL_MULTISAMPLE);
@@ -197,11 +198,7 @@ void OpenGLPipelineState::SetClearColor(float r, float g, float b, float a) {
}
void OpenGLPipelineState::Clear(unsigned int buffers) {
unsigned int 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;
glClear(glBuffers);
glClear(ToOpenGLClearBuffer(buffers));
}
void OpenGLPipelineState::AttachShader(unsigned int program) {

14
engine/src/RHI/OpenGL/OpenGLRenderTargetView.cpp
View File

@@ -1,20 +1,10 @@
#include "XCEngine/RHI/OpenGL/OpenGLRenderTargetView.h"
#include "XCEngine/RHI/OpenGL/OpenGLEnums.h"
#include <glad/glad.h>
namespace XCEngine {
namespace RHI {
static unsigned int ToGLRenderTargetType(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;
}
}
OpenGLRenderTargetView::OpenGLRenderTargetView()
: m_texture(0)
, m_framebuffer(0)
@@ -36,7 +26,7 @@ bool OpenGLRenderTargetView::Initialize(unsigned int texture, const OpenGLRender
glGenFramebuffers(1, &m_framebuffer);
glBindFramebuffer(GL_FRAMEBUFFER, m_framebuffer);
unsigned int target = ToGLRenderTargetType(desc.type);
unsigned int target = ToOpenGL(desc.type);
GLenum attachment = GL_COLOR_ATTACHMENT0;
switch (desc.type) {

33
engine/src/RHI/OpenGL/OpenGLSampler.cpp
View File

@@ -1,31 +1,10 @@
#include "XCEngine/RHI/OpenGL/OpenGLSampler.h"
#include "XCEngine/RHI/OpenGL/OpenGLEnums.h"
#include <glad/glad.h>
namespace XCEngine {
namespace RHI {
static unsigned int ToGLWrapMode(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;
}
}
static unsigned int ToGLFilter(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;
}
}
OpenGLSampler::OpenGLSampler() : m_sampler(0) {
}
@@ -36,11 +15,11 @@ bool OpenGLSampler::Initialize(const OpenGLSamplerDesc& desc) {
m_desc = desc;
glGenSamplers(1, &m_sampler);
glSamplerParameteri(m_sampler, GL_TEXTURE_MIN_FILTER, ToGLFilter(desc.minFilter));
glSamplerParameteri(m_sampler, GL_TEXTURE_MAG_FILTER, ToGLFilter(desc.magFilter));
glSamplerParameteri(m_sampler, GL_TEXTURE_WRAP_S, ToGLWrapMode(desc.wrapS));
glSamplerParameteri(m_sampler, GL_TEXTURE_WRAP_T, ToGLWrapMode(desc.wrapT));
glSamplerParameteri(m_sampler, GL_TEXTURE_WRAP_R, ToGLWrapMode(desc.wrapR));
glSamplerParameteri(m_sampler, GL_TEXTURE_MIN_FILTER, ToOpenGL(desc.minFilter));
glSamplerParameteri(m_sampler, GL_TEXTURE_MAG_FILTER, ToOpenGL(desc.magFilter));
glSamplerParameteri(m_sampler, GL_TEXTURE_WRAP_S, ToOpenGL(desc.wrapS));
glSamplerParameteri(m_sampler, GL_TEXTURE_WRAP_T, ToOpenGL(desc.wrapT));
glSamplerParameteri(m_sampler, GL_TEXTURE_WRAP_R, ToOpenGL(desc.wrapR));
glSamplerParameterf(m_sampler, GL_TEXTURE_MIN_LOD, desc.minLod);
glSamplerParameterf(m_sampler, GL_TEXTURE_MAX_LOD, desc.maxLod);
glSamplerParameterf(m_sampler, GL_TEXTURE_MAX_ANISOTROPY, desc.maxAnisotropy);

6
engine/src/RHI/OpenGL/OpenGLScreenshot.cpp
View File

@@ -61,5 +61,11 @@ bool OpenGLScreenshot::Capture(OpenGLDevice& device, OpenGLSwapChain& swapChain,
return true;
}
bool OpenGLScreenshot::Capture(RHIDevice* device, RHISwapChain* swapChain, const char* filename) {
auto* oglDevice = static_cast<OpenGLDevice*>(device);
auto* oglSwapChain = static_cast<OpenGLSwapChain*>(swapChain);
return Capture(*oglDevice, *oglSwapChain, filename);
}
} // namespace RHI
} // namespace XCEngine

66
engine/src/RHI/OpenGL/OpenGLTexture.cpp
View File

@@ -1,4 +1,5 @@
#include "XCEngine/RHI/OpenGL/OpenGLTexture.h"
#include "XCEngine/RHI/OpenGL/OpenGLEnums.h"
#include <glad/glad.h>
#include <stb_image.h>
#include <iostream>
@@ -6,47 +7,6 @@
namespace XCEngine {
namespace RHI {
static unsigned int ToGLTextureTarget(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;
}
}
static void ToGLFormat(OpenGLFormat fmt, unsigned int& internalFormat, unsigned int& glFormat, unsigned int& 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;
}
}
OpenGLTexture::OpenGLTexture()
: m_texture(0)
, m_type(OpenGLTextureType::Texture2D)
@@ -68,9 +28,10 @@ bool OpenGLTexture::Initialize(OpenGLTextureType type, int width, int height, in
m_depth = depth;
m_mipLevels = mipLevels;
unsigned int target = ToGLTextureTarget(type);
unsigned int internalFormat, glFormat, glType;
ToGLFormat(format, internalFormat, glFormat, glType);
unsigned int target = ToOpenGL(type);
GLint internalFormat;
GLenum glFormat, glType;
ToOpenGLFormat(format, internalFormat, glFormat, glType);
glGenTextures(1, &m_texture);
glBindTexture(target, m_texture);
@@ -136,8 +97,9 @@ bool OpenGLTexture::InitializeCubeMap(int size, int mipLevels, OpenGLFormat form
m_depth = 1;
m_mipLevels = mipLevels;
unsigned int internalFormat, glFormat, glType;
ToGLFormat(format, internalFormat, glFormat, glType);
GLint internalFormat;
GLenum glFormat, glType;
ToOpenGLFormat(format, internalFormat, glFormat, glType);
glGenTextures(1, &m_texture);
glBindTexture(GL_TEXTURE_CUBE_MAP, m_texture);
@@ -178,31 +140,31 @@ void OpenGLTexture::Shutdown() {
}
void OpenGLTexture::Bind(int slot) const {
unsigned int target = ToGLTextureTarget(m_type);
unsigned int target = ToOpenGL(m_type);
glActiveTexture(GL_TEXTURE0 + slot);
glBindTexture(target, m_texture);
}
void OpenGLTexture::Unbind() const {
unsigned int target = ToGLTextureTarget(m_type);
unsigned int target = ToOpenGL(m_type);
glBindTexture(target, 0);
}
void OpenGLTexture::BindImage(int slot, bool read, bool write) const {
unsigned int target = ToGLTextureTarget(m_type);
unsigned int target = ToOpenGL(m_type);
GLenum access = (read && write) ? GL_READ_WRITE : (read ? GL_READ_ONLY : GL_WRITE_ONLY);
glBindImageTexture(slot, m_texture, 0, GL_FALSE, 0, access, GL_RGBA8);
}
void OpenGLTexture::GenerateMipmap() {
unsigned int target = ToGLTextureTarget(m_type);
unsigned int target = ToOpenGL(m_type);
glBindTexture(target, m_texture);
glGenerateMipmap(target);
glBindTexture(target, 0);
}
void OpenGLTexture::SetFiltering(int minFilter, int magFilter) {
unsigned int target = ToGLTextureTarget(m_type);
unsigned int target = ToOpenGL(m_type);
glBindTexture(target, m_texture);
glTexParameteri(target, GL_TEXTURE_MIN_FILTER, minFilter);
glTexParameteri(target, GL_TEXTURE_MAG_FILTER, magFilter);
@@ -210,7 +172,7 @@ void OpenGLTexture::SetFiltering(int minFilter, int magFilter) {
}
void OpenGLTexture::SetWrapping(int wrapS, int wrapT, int wrapR) {
unsigned int target = ToGLTextureTarget(m_type);
unsigned int target = ToOpenGL(m_type);
glBindTexture(target, m_texture);
glTexParameteri(target, GL_TEXTURE_WRAP_S, wrapS);
glTexParameteri(target, GL_TEXTURE_WRAP_T, wrapT);

22
engine/src/RHI/OpenGL/OpenGLVertexArray.cpp
View File

@@ -1,28 +1,10 @@
#include "XCEngine/RHI/OpenGL/OpenGLVertexArray.h"
#include "XCEngine/RHI/OpenGL/OpenGLEnums.h"
#include <glad/glad.h>
namespace XCEngine {
namespace RHI {
static unsigned int ToGLAttributeType(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;
}
}
OpenGLVertexArray::OpenGLVertexArray()
: m_vao(0)
, m_indexBuffer(0)
@@ -44,7 +26,7 @@ void OpenGLVertexArray::AddVertexBuffer(unsigned int buffer, const VertexAttribu
glBindBuffer(GL_ARRAY_BUFFER, buffer);
glEnableVertexAttribArray(attribute.index);
glVertexAttribPointer(attribute.index, attribute.count,
ToGLAttributeType(attribute.type),
ToOpenGL(attribute.type),
attribute.normalized == VertexAttributeNormalized::True ? GL_TRUE : GL_FALSE,
attribute.stride, (void*)attribute.offset);
glBindBuffer(GL_ARRAY_BUFFER, 0);