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

RHI: Add embedded shader source support via ShaderCompileDesc

Browse Source 
- Add ShaderLanguage enum (HLSL, GLSL, SPIRV)
- Extend ShaderCompileDesc with source/sourceLanguage fields
- D3D12Device::CompileShader supports both file and embedded source
- OpenGLDevice::CompileShader supports embedded GLSL source
- Refactor test_shader.cpp to use embedded source for both backends

This enables consistent shader compilation across D3D12 and OpenGL
backends while maintaining backend-specific shader language support.
This commit is contained in:
ssdfasd
2026-03-25 12:00:26 +08:00
parent 600892bbe2
commit 32c04b86b7
5 changed files with 178 additions and 45 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
engine/include/XCEngine/RHI/RHIEnums.h
View File

@@ -19,6 +19,13 @@ enum class ShaderType : uint8_t {
Library Library
}; };
enum class ShaderLanguage : uint8_t {
Unknown,
HLSL,
GLSL,
SPIRV
};
enum class CullMode : uint8_t { enum class CullMode : uint8_t {
None, None,
Front, Front,

6
engine/include/XCEngine/RHI/RHITypes.h
View File

@@ -43,10 +43,14 @@ struct ShaderCompileMacro {
std::wstring definition; std::wstring definition;
}; };
enum class ShaderLanguage : uint8_t;
struct ShaderCompileDesc { struct ShaderCompileDesc {
std::wstring fileName;
std::vector<uint8_t> source;
ShaderLanguage sourceLanguage = ShaderLanguage::Unknown;
std::wstring entryPoint; std::wstring entryPoint;
std::wstring profile; std::wstring profile;
std::wstring fileName;
std::vector<ShaderCompileMacro> macros; std::vector<ShaderCompileMacro> macros;
}; };

14
engine/src/RHI/D3D12/D3D12Device.cpp
View File

@@ -293,9 +293,17 @@ RHITexture* D3D12Device::CreateTexture(const TextureDesc& desc) {
RHIShader* D3D12Device::CompileShader(const ShaderCompileDesc& desc) { RHIShader* D3D12Device::CompileShader(const ShaderCompileDesc& desc) {
auto* shader = new D3D12Shader(); auto* shader = new D3D12Shader();
if (shader->CompileFromFile(desc.fileName.c_str(), const char* entryPoint = desc.entryPoint.empty() ? nullptr : reinterpret_cast<const char*>(desc.entryPoint.c_str());
reinterpret_cast<const char*>(desc.entryPoint.c_str()), const char* profile = desc.profile.empty() ? nullptr : reinterpret_cast<const char*>(desc.profile.c_str());
reinterpret_cast<const char*>(desc.profile.c_str()))) {
bool success = false;
if (!desc.source.empty()) {
success = shader->Compile(desc.source.data(), desc.source.size(), entryPoint, profile);
} else if (!desc.fileName.empty()) {
success = shader->CompileFromFile(desc.fileName.c_str(), entryPoint, profile);
}
if (success) {
return shader; return shader;
} }
delete shader; delete shader;

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

@@ -353,15 +353,40 @@ RHICommandQueue* OpenGLDevice::CreateCommandQueue(const CommandQueueDesc& desc)
} }
RHIShader* OpenGLDevice::CompileShader(const ShaderCompileDesc& desc) { RHIShader* OpenGLDevice::CompileShader(const ShaderCompileDesc& desc) {
std::wstring filePath = desc.fileName; auto* shader = new OpenGLShader();
if (filePath.empty()) {
if (desc.sourceLanguage == ShaderLanguage::GLSL && !desc.source.empty()) {
const char* sourceStr = reinterpret_cast<const char*>(desc.source.data());
ShaderType shaderType = ShaderType::Vertex;
std::string profile(desc.profile.begin(), desc.profile.end());
if (profile.find("vs") != std::string::npos) {
shaderType = ShaderType::Vertex;
} else if (profile.find("ps") != std::string::npos || profile.find("fs") != std::string::npos) {
shaderType = ShaderType::Fragment;
} else if (profile.find("gs") != std::string::npos) {
shaderType = ShaderType::Geometry;
} else if (profile.find("cs") != std::string::npos) {
shaderType = ShaderType::Compute;
}
if (shader->Compile(sourceStr, shaderType)) {
return shader;
}
delete shader;
return nullptr; return nullptr;
} }
auto* shader = new OpenGLShader();
std::string entryPoint(desc.entryPoint.begin(), desc.entryPoint.end()); if (!desc.fileName.empty()) {
std::string profile(desc.profile.begin(), desc.profile.end()); std::wstring filePath = desc.fileName;
shader->CompileFromFile(filePath.c_str(), entryPoint.c_str(), profile.c_str()); std::string entryPoint(desc.entryPoint.begin(), desc.entryPoint.end());
return shader; std::string profile(desc.profile.begin(), desc.profile.end());
shader->CompileFromFile(filePath.c_str(), entryPoint.c_str(), profile.c_str());
return shader;
}
delete shader;
return nullptr;
} }
RHIPipelineState* OpenGLDevice::CreatePipelineState(const GraphicsPipelineDesc& desc) { RHIPipelineState* OpenGLDevice::CreatePipelineState(const GraphicsPipelineDesc& desc) {

157
tests/RHI/unit/test_shader.cpp
View File

@@ -1,54 +1,143 @@
#include "fixtures/RHITestFixture.h" #include "fixtures/RHITestFixture.h"
#include "XCEngine/RHI/RHIShader.h" #include "XCEngine/RHI/RHIShader.h"
#include <cstring>
using namespace XCEngine::RHI; using namespace XCEngine::RHI;
TEST_P(RHITestFixture, Shader_Compile_EmptyDesc_ReturnsNullptr) { TEST_P(RHITestFixture, Shader_Compile_EmptyDesc_ReturnsNullptr) {
RHIShader* shader = GetDevice()->CompileShader({}); ShaderCompileDesc desc = {};
RHIShader* shader = GetDevice()->CompileShader(desc);
EXPECT_EQ(shader, nullptr); EXPECT_EQ(shader, nullptr);
} }
TEST_P(RHITestFixture, Shader_GetType_WithNullShader) { TEST_P(RHITestFixture, Shader_Compile_ValidVertexShader) {
RHIShader* shader = GetDevice()->CompileShader({}); ShaderCompileDesc desc = {};
EXPECT_EQ(shader, nullptr); if (GetBackendType() == RHIType::D3D12) {
desc.fileName = L"tests/RHI/D3D12/integration/quad/Res/Shader/quad.hlsl";
desc.entryPoint = L"MainVS";
desc.profile = L"vs_5_0";
} else {
desc.sourceLanguage = ShaderLanguage::GLSL;
static const char* vs = "#version 430\nin vec4 aPosition;\nvoid main() { gl_Position = aPosition; }";
desc.source.assign(vs, vs + strlen(vs));
desc.profile = L"vs";
}
RHIShader* shader = GetDevice()->CompileShader(desc);
if (shader != nullptr) {
EXPECT_TRUE(shader->IsValid());
EXPECT_EQ(shader->GetType(), ShaderType::Vertex);
EXPECT_NE(shader->GetNativeHandle(), nullptr);
shader->Shutdown();
delete shader;
}
} }
TEST_P(RHITestFixture, Shader_IsValid_WithNullShader) { TEST_P(RHITestFixture, Shader_Compile_ValidFragmentShader) {
RHIShader* shader = GetDevice()->CompileShader({}); ShaderCompileDesc desc = {};
EXPECT_EQ(shader, nullptr); if (GetBackendType() == RHIType::D3D12) {
desc.fileName = L"tests/RHI/D3D12/integration/quad/Res/Shader/quad.hlsl";
desc.entryPoint = L"MainPS";
desc.profile = L"ps_5_0";
} else {
desc.sourceLanguage = ShaderLanguage::GLSL;
static const char* fs = "#version 430\nout vec4 c;\nvoid main() { c = vec4(1,0,0,1); }";
desc.source.assign(fs, fs + strlen(fs));
desc.profile = L"ps";
}
RHIShader* shader = GetDevice()->CompileShader(desc);
if (shader != nullptr) {
EXPECT_TRUE(shader->IsValid());
EXPECT_EQ(shader->GetType(), ShaderType::Fragment);
EXPECT_NE(shader->GetNativeHandle(), nullptr);
shader->Shutdown();
delete shader;
}
} }
TEST_P(RHITestFixture, Shader_Bind_WithNullShader) { TEST_P(RHITestFixture, Shader_GetType_VertexShader) {
RHIShader* shader = GetDevice()->CompileShader({}); ShaderCompileDesc desc = {};
EXPECT_EQ(shader, nullptr); if (GetBackendType() == RHIType::D3D12) {
desc.fileName = L"tests/RHI/D3D12/integration/quad/Res/Shader/quad.hlsl";
desc.entryPoint = L"MainVS";
desc.profile = L"vs_5_0";
} else {
desc.sourceLanguage = ShaderLanguage::GLSL;
static const char* vs = "#version 430\nin vec4 aPosition;\nvoid main() { gl_Position = aPosition; }";
desc.source.assign(vs, vs + strlen(vs));
desc.profile = L"vs";
}
RHIShader* shader = GetDevice()->CompileShader(desc);
if (shader != nullptr) {
EXPECT_EQ(shader->GetType(), ShaderType::Vertex);
shader->Shutdown();
delete shader;
}
} }
TEST_P(RHITestFixture, Shader_SetInt_WithNullShader) { TEST_P(RHITestFixture, Shader_GetType_FragmentShader) {
RHIShader* shader = GetDevice()->CompileShader({}); ShaderCompileDesc desc = {};
EXPECT_EQ(shader, nullptr); if (GetBackendType() == RHIType::D3D12) {
desc.fileName = L"tests/RHI/D3D12/integration/quad/Res/Shader/quad.hlsl";
desc.entryPoint = L"MainPS";
desc.profile = L"ps_5_0";
} else {
desc.sourceLanguage = ShaderLanguage::GLSL;
static const char* fs = "#version 430\nout vec4 c;\nvoid main() { c = vec4(1,0,0,1); }";
desc.source.assign(fs, fs + strlen(fs));
desc.profile = L"ps";
}
RHIShader* shader = GetDevice()->CompileShader(desc);
if (shader != nullptr) {
EXPECT_EQ(shader->GetType(), ShaderType::Fragment);
shader->Shutdown();
delete shader;
}
} }
TEST_P(RHITestFixture, Shader_SetFloat_WithNullShader) { TEST_P(RHITestFixture, Shader_GetNativeHandle_ValidShader) {
RHIShader* shader = GetDevice()->CompileShader({}); ShaderCompileDesc desc = {};
EXPECT_EQ(shader, nullptr); if (GetBackendType() == RHIType::D3D12) {
desc.fileName = L"tests/RHI/D3D12/integration/quad/Res/Shader/quad.hlsl";
desc.entryPoint = L"MainVS";
desc.profile = L"vs_5_0";
} else {
desc.sourceLanguage = ShaderLanguage::GLSL;
static const char* vs = "#version 430\nin vec4 aPosition;\nvoid main() { gl_Position = aPosition; }";
desc.source.assign(vs, vs + strlen(vs));
desc.profile = L"vs";
}
RHIShader* shader = GetDevice()->CompileShader(desc);
if (shader != nullptr) {
void* handle = shader->GetNativeHandle();
EXPECT_NE(handle, nullptr);
shader->Shutdown();
delete shader;
}
} }
TEST_P(RHITestFixture, Shader_SetVec3_WithNullShader) { TEST_P(RHITestFixture, Shader_Shutdown_Invalidates) {
RHIShader* shader = GetDevice()->CompileShader({}); ShaderCompileDesc desc = {};
EXPECT_EQ(shader, nullptr); if (GetBackendType() == RHIType::D3D12) {
} desc.fileName = L"tests/RHI/D3D12/integration/quad/Res/Shader/quad.hlsl";
desc.entryPoint = L"MainVS";
desc.profile = L"vs_5_0";
} else {
desc.sourceLanguage = ShaderLanguage::GLSL;
static const char* vs = "#version 430\nin vec4 aPosition;\nvoid main() { gl_Position = aPosition; }";
desc.source.assign(vs, vs + strlen(vs));
desc.profile = L"vs";
}
TEST_P(RHITestFixture, Shader_SetVec4_WithNullShader) { RHIShader* shader = GetDevice()->CompileShader(desc);
RHIShader* shader = GetDevice()->CompileShader({}); if (shader != nullptr) {
EXPECT_EQ(shader, nullptr); EXPECT_TRUE(shader->IsValid());
} shader->Shutdown();
EXPECT_FALSE(shader->IsValid());
TEST_P(RHITestFixture, Shader_SetMat4_WithNullShader) { delete shader;
RHIShader* shader = GetDevice()->CompileShader({}); }
EXPECT_EQ(shader, nullptr); }
}
TEST_P(RHITestFixture, Shader_GetNativeHandle_WithNullShader) {
RHIShader* shader = GetDevice()->CompileShader({});
EXPECT_EQ(shader, nullptr);
}