swung0x48/MobileGL
1
0
Fork 0
mirror of https://github.com/MobileGL-Dev/MobileGL synced 2026-09-09 04:38:30 +09:00
Code Issues Packages Projects Releases Wiki Activity

[Fix] (MG_Backend/DirectGLES): Actually compile shader and use.

Browse Source 
* TODO: remove junk code.
This commit is contained in:
BZLZHH
2025-10-26 11:43:10 +08:00
parent b8d8188239
commit 5da6a0e05e
7 changed files with 168 additions and 25 deletions
Download Patch File Download Diff File Expand all files Collapse all files
MobileGL/MG_Backend/DirectGLES/Managers.cpp
+141 -21
View File
@@ -1,4 +1,7 @@
#include "Managers.h"
#include "MG_Backend/Backends.h"
#include "MG_State/GLState/ProgramState/ShaderObject.h"
#include "MG_Util/Types.h"
#include "Utils.h"
#include "DirectGLES.h"
#include <MG_Util/BackendLoaders/OpenGL/Loader.h>
@@ -147,7 +150,7 @@ namespace MobileGL::MG_Backend::DirectGLES {
return;
}
MGLOG_D("Syncing VAO object with ID: %u to backend for state: %s", m_backendVAOId, stateVAOObject.get());
MGLOG_D("Syncing VAO object with ID: %u to backend for state: 0x%p", m_backendVAOId, stateVAOObject.get());
BufferImpl::BackendBufferBindingProtector backendBufferBindingProtector(BufferImpl::TempBufferTarget);
BackendVertexArrayBindingProtector backendVAOBindingProtector;
@@ -222,7 +225,7 @@ namespace MobileGL::MG_Backend::DirectGLES {
return;
}
MGLOG_D("Syncing texture object with ID: %u to backend for state: %s", m_backendTextureId,
MGLOG_D("Syncing texture object with ID: %u to backend for state: 0x%p", m_backendTextureId,
stateTextureObject.get());
GLenum target = MG_Util::ConvertTextureTargetToGLEnum(stateTextureObject->GetTarget());
@@ -340,7 +343,7 @@ namespace MobileGL::MG_Backend::DirectGLES {
return;
}
MGLOG_D("Syncing FBO object with ID: %u to backend for state: %s", m_backendFBOId, stateFBOObject.get());
MGLOG_D("Syncing FBO object with ID: %u to backend for state: 0x%p", m_backendFBOId, stateFBOObject.get());
BackendFramebufferBindingProtector backendFBOBindingProtector(GL_FRAMEBUFFER);
Bind();
@@ -352,9 +355,6 @@ namespace MobileGL::MG_Backend::DirectGLES {
FramebufferAttachmentType attachmentType = static_cast<FramebufferAttachmentType>(index);
const auto& attachment = attachments[index];
if (!attachment.IsComplete()) {
MG_External::GLES::glFramebufferRenderbuffer(
GL_FRAMEBUFFER, MG_Util::ConvertFramebufferAttachmentTypeToGLEnum(attachmentType),
GL_RENDERBUFFER, 0);
continue;
}
@@ -386,31 +386,50 @@ namespace MobileGL::MG_Backend::DirectGLES {
g_backendShaderObjects;
UnorderedMap<SharedPtr<MG_State::GLState::ProgramObject>, SharedPtr<BackendProgramObjectImpl>>
g_backendProgramObjects;
BackendShaderObjectImpl::BackendShaderObjectImpl() {
m_backendShaderId = MG_External::GLES::glCreateShader(GL_VERTEX_SHADER);
if (m_backendShaderId == 0) {
MGLOG_E("Failed to create shader object in backend.");
} else {
MGLOG_D("Created backend shader object with ID: %u", m_backendShaderId);
}
}
BackendShaderObjectImpl::~BackendShaderObjectImpl() {
if (m_backendShaderId != 0) {
MGLOG_D("Deleting backend shader object with ID: %u", m_backendShaderId);
MG_External::GLES::glDeleteShader(m_backendShaderId);
}
}
void BackendShaderObjectImpl::SyncToBackend(SharedPtr<MG_State::GLState::ShaderObject>& stateShaderObject) {
if (!stateShaderObject || !stateShaderObject->GetCompileStatus()) {
MGLOG_E("Shader object is null or not compiled, skipping backend sync.");
if (!stateShaderObject) {
MGLOG_E("State shader object is null, skipping backend sync.");
return;
}
String source = stateShaderObject->GetShaderSource();
source = removeLayoutBinding(source);
source = ProcessOutColorLocations(source);
source = ForceSupporterOutput(source);
GLenum shaderType = ConvertGLShaderTypeByMGLShaderStage(stateShaderObject->GetShaderStage());
if (!stateShaderObject->GetCompileStatus()) {
MGLOG_E("Shader object is not compiled, skipping backend sync. Shader: 0x%p", stateShaderObject.get());
return;
}
MGLOG_D("Syncing shader to backend. State shader: 0x%p, Backend ID: %u, Stage: %s", stateShaderObject.get(),
m_backendShaderId,
MG_Util::ConvertGLEnumToString(
MG_State::GLState::ConvertGLShaderTypeByMGLShaderStage(stateShaderObject->GetShaderStage()))
.c_str());
auto shaderTShader = stateShaderObject->GetCompiledShader();
String source = ConvertTShaderToGLSL(shaderTShader, 320, true); // TODO: get real version
const char* sourceCStr = source.c_str();
MGLOG_D("Setting shader source for backend shader ID: %u", m_backendShaderId);
MG_External::GLES::glShaderSource(m_backendShaderId, 1, &sourceCStr, nullptr);
MGLOG_D("Compiling shader. Backend ID: %u", m_backendShaderId);
MG_External::GLES::glCompileShader(m_backendShaderId);
GLint compileStatus;
MG_External::GLES::glGetShaderiv(m_backendShaderId, GL_COMPILE_STATUS, &compileStatus);
if (compileStatus != GL_TRUE) {
@@ -418,47 +437,135 @@ namespace MobileGL::MG_Backend::DirectGLES {
MG_External::GLES::glGetShaderiv(m_backendShaderId, GL_INFO_LOG_LENGTH, &logLength);
Vector<GLchar> log(logLength);
MG_External::GLES::glGetShaderInfoLog(m_backendShaderId, logLength, nullptr, log.data());
MGLOG_E("Shader compilation failed: %s", log.data());
MGLOG_E("Shader compilation failed for backend ID %u: %s", m_backendShaderId, log.data());
} else {
MGLOG_D("Shader compiled successfully. Backend ID: %u", m_backendShaderId);
}
m_isInitialized = true;
MGLOG_D("Shader sync completed. Backend ID: %u", m_backendShaderId);
}
BackendProgramObjectImpl::BackendProgramObjectImpl() {
m_backendProgramId = MG_External::GLES::glCreateProgram();
if (m_backendProgramId == 0) {
MGLOG_E("Failed to create program object in backend.");
} else {
MGLOG_D("Created backend program object with ID: %u", m_backendProgramId);
}
}
BackendProgramObjectImpl::~BackendProgramObjectImpl() {
if (m_backendProgramId != 0) {
MGLOG_D("Deleting backend program object with ID: %u", m_backendProgramId);
MG_External::GLES::glDeleteProgram(m_backendProgramId);
}
}
void BackendProgramObjectImpl::SyncToBackend(SharedPtr<MG_State::GLState::ProgramObject>& stateProgramObject) {
if (!stateProgramObject || !stateProgramObject->GetLinkStatus()) {
MGLOG_E("Program object is null or not linked, skipping backend sync.");
if (!stateProgramObject) {
MGLOG_E("State program object is null, skipping backend sync.");
return;
}
if (!stateProgramObject->GetLinkStatus()) {
MGLOG_E("Program object is not linked, skipping backend sync. Program: 0x%p", stateProgramObject.get());
return;
}
MGLOG_D("Syncing program to backend. State program: 0x%p, Backend ID: 0x%p", stateProgramObject.get(),
m_backendProgramId);
// Detach all existing shaders
GLint attachedCount = 0;
MG_External::GLES::glGetProgramiv(m_backendProgramId, GL_ATTACHED_SHADERS, &attachedCount);
MGLOG_D("Currently attached shaders count: %d", attachedCount);
if (attachedCount > 0) {
Vector<GLuint> attachedShaders(attachedCount);
GLsizei actualCount;
MG_External::GLES::glGetAttachedShaders(m_backendProgramId, attachedCount, &actualCount,
attachedShaders.data());
MGLOG_D("Detaching %d existing shaders from program %u", actualCount, m_backendProgramId);
for (GLsizei i = 0; i < actualCount; ++i) {
MGLOG_D("Detaching shader ID: %u from program %u", attachedShaders[i], m_backendProgramId);
MG_External::GLES::glDetachShader(m_backendProgramId, attachedShaders[i]);
}
}
// Attach current shaders
for (const auto& shader : stateProgramObject->GetAttachedShaders()) {
const auto& it = g_backendShaderObjects.find(shader);
if (it != g_backendShaderObjects.end() && it->second) {
MG_External::GLES::glAttachShader(m_backendProgramId, it->second->GetBackendShaderId());
auto& attachedShaders = stateProgramObject->GetAttachedShaders();
MGLOG_D("Attaching %zu shaders to program %u", attachedShaders.size(), m_backendProgramId);
auto& shaderSpirvs = stateProgramObject->GetGeneratedSpirv();
for (int index = 0; index < attachedShaders.size(); ++index) {
auto& shader = attachedShaders[index];
GLenum glShaderType = MG_State::GLState::ConvertGLShaderTypeByMGLShaderStage(shader->GetShaderStage());
GLuint backendShaderId = MG_External::GLES::glCreateShader(glShaderType);
if (backendShaderId == 0) {
MGLOG_E("Failed to create backend shader for attachment.");
continue;
}
String source;
auto& spirvCode = shaderSpirvs[index];
MG_Util::ShaderTranspiler::SpvcSession spvcSession(spirvCode);
spvc_compiler_options options;
spvcSession.CreateOptions(&options);
spvc_compiler_options_set_uint(options, SPVC_COMPILER_OPTION_GLSL_VERSION, 320);
spvc_compiler_options_set_bool(options, SPVC_COMPILER_OPTION_GLSL_ES, SPVC_TRUE);
spvc_compiler_options_set_bool(options, SPVC_COMPILER_OPTION_GLSL_VULKAN_SEMANTICS, SPVC_FALSE);
spvcSession.SetOptions(options);
const char* result = nullptr;
spvcSession.Compile(&result);
if (!result) {
MG_Util::ShaderTranspiler::ResultInfo r;
r.log += "Failed to compile the shader to GLSL: \n";
r.log += spvcSession.GetLastErrorString();
r.errc = -5;
MGLOG_E("%s", r.log.c_str());
continue;
}
source = result;
source = RemoveLayoutBinding(source);
source = ProcessOutColorLocations(source);
source = ForceSupporterOutput(source);
const char* sourceCStr = source.c_str();
MGLOG_D("Setting shader source for backend shader ID: %u", backendShaderId);
MG_External::GLES::glShaderSource(backendShaderId, 1, &sourceCStr, nullptr);
MG_External::GLES::glCompileShader(backendShaderId);
GLint compileStatus;
MG_External::GLES::glGetShaderiv(backendShaderId, GL_COMPILE_STATUS, &compileStatus);
if (compileStatus == GL_FALSE) {
GLint logLength;
MG_External::GLES::glGetShaderiv(backendShaderId, GL_INFO_LOG_LENGTH, &logLength);
Vector<GLchar> log(logLength);
MG_External::GLES::glGetShaderInfoLog(backendShaderId, logLength, nullptr, log.data());
MGLOG_E("Shader compilation failed for backend ID %u: %s", backendShaderId, log.data());
continue;
}
MGLOG_D("Attaching shader ID: %u to program %u", backendShaderId, m_backendProgramId);
MG_External::GLES::glAttachShader(m_backendProgramId, backendShaderId);
MGLOG_D("Processed shader source length: %zu", source.length());
}
// Link program
MGLOG_D("Linking program %u", m_backendProgramId);
MG_External::GLES::glLinkProgram(m_backendProgramId);
GLint linkStatus;
MG_External::GLES::glGetProgramiv(m_backendProgramId, GL_LINK_STATUS, &linkStatus);
if (linkStatus != GL_TRUE) {
@@ -466,11 +573,24 @@ namespace MobileGL::MG_Backend::DirectGLES {
MG_External::GLES::glGetProgramiv(m_backendProgramId, GL_INFO_LOG_LENGTH, &logLength);
Vector<GLchar> log(logLength);
MG_External::GLES::glGetProgramInfoLog(m_backendProgramId, logLength, nullptr, log.data());
MGLOG_E("Program linking failed: %s", log.data());
MGLOG_E("Program linking failed for %u: %s", m_backendProgramId, log.data());
} else {
MGLOG_D("Program linked successfully. ID: %u", m_backendProgramId);
}
// Create global UBO
MG_External::GLES::glGenBuffers(1, &m_backendGlobalUBOId);
MG_External::GLES::glBindBuffer(GL_UNIFORM_BUFFER, m_backendGlobalUBOId);
MG_External::GLES::glBufferData(GL_UNIFORM_BUFFER, stateProgramObject->GetUBOSize(), nullptr,
GL_STREAM_DRAW);
MG_External::GLES::glBindBuffer(GL_UNIFORM_BUFFER, 0);
m_isInitialized = true;
MGLOG_D("Program sync completed. Backend ID: %u", m_backendProgramId);
}
void BackendProgramObjectImpl::Use() {
MGLOG_D("Using program %u", m_backendProgramId);
MG_External::GLES::glUseProgram(m_backendProgramId);
}
} // namespace PrgramImpl