Skip to content

A fast 2D and 3D game engine — TypeScript SDK, C++/WebAssembly core, visual editor. Ship one project to web, desktop, WeChat MiniGames, playable ads, and native Android / iOS.

feat(shader): end-to-end compile-error remap to original files

esenginef37cedcd49df
diff --git a/src/esengine/renderer/Shader.cpp b/src/esengine/renderer/Shader.cpp
index 6c5fc4a50..4dcd8e202 100644
--- a/src/esengine/renderer/Shader.cpp
+++ b/src/esengine/renderer/Shader.cpp
@@ -119,47 +119,70 @@ void Shader::unbind() const {
glUseProgram(0);
}
+namespace {
+
+std::string readShaderInfoLog(GLuint shader) {
+ GLint logLength = 0;
+ glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &logLength);
+ if (logLength <= 0) return {};
+ std::string log(static_cast<size_t>(logLength), '\0');
+ glGetShaderInfoLog(shader, logLength, nullptr, log.data());
+ // Drop the trailing NUL glGetShaderInfoLog writes inside the buffer.
+ if (!log.empty() && log.back() == '\0') log.pop_back();
+ return log;
+}
+
+std::string readProgramInfoLog(GLuint program) {
+ GLint logLength = 0;
+ glGetProgramiv(program, GL_INFO_LOG_LENGTH, &logLength);
+ if (logLength <= 0) return {};
+ std::string log(static_cast<size_t>(logLength), '\0');
+ glGetProgramInfoLog(program, logLength, nullptr, log.data());
+ if (!log.empty() && log.back() == '\0') log.pop_back();
+ return log;
+}
+
+} // namespace
+
bool Shader::compile(const std::string& vertexSrc, const std::string& fragmentSrc,
- std::initializer_list<AttribBinding> bindings) {
- // Create vertex shader
+ std::initializer_list<AttribBinding> bindings,
+ std::string* outLog,
+ ShaderStageFailure* outFailedStage) {
+ auto setFailure = [&](ShaderStageFailure stage, std::string&& log) {
+ if (outLog) *outLog = std::move(log);
+ if (outFailedStage) *outFailedStage = stage;
+ };
+
GLuint vertexShader = glCreateShader(GL_VERTEX_SHADER);
const char* vertexSrcPtr = vertexSrc.c_str();
glShaderSource(vertexShader, 1, &vertexSrcPtr, nullptr);
glCompileShader(vertexShader);
- // Check vertex shader compilation
GLint success;
glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &success);
if (!success) {
- GLint logLength;
- glGetShaderiv(vertexShader, GL_INFO_LOG_LENGTH, &logLength);
- std::string log(logLength, '\0');
- glGetShaderInfoLog(vertexShader, logLength, nullptr, log.data());
+ std::string log = readShaderInfoLog(vertexShader);
ES_LOG_ERROR("Vertex shader compilation failed: {}", log);
+ setFailure(ShaderStageFailure::Vertex, std::move(log));
glDeleteShader(vertexShader);
return false;
}
- // Create fragment shader
GLuint fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
const char* fragmentSrcPtr = fragmentSrc.c_str();
glShaderSource(fragmentShader, 1, &fragmentSrcPtr, nullptr);
glCompileShader(fragmentShader);
- // Check fragment shader compilation
glGetShaderiv(fragmentShader, GL_COMPILE_STATUS, &success);
if (!success) {
- GLint logLength;
- glGetShaderiv(fragmentShader, GL_INFO_LOG_LENGTH, &logLength);
- std::string log(logLength, '\0');
- glGetShaderInfoLog(fragmentShader, logLength, nullptr, log.data());
+ std::string log = readShaderInfoLog(fragmentShader);
ES_LOG_ERROR("Fragment shader compilation failed: {}", log);
+ setFailure(ShaderStageFailure::Fragment, std::move(log));
glDeleteShader(vertexShader);
glDeleteShader(fragmentShader);
return false;
}
- // Create program and link
programId_ = glCreateProgram();
glAttachShader(programId_, vertexShader);
glAttachShader(programId_, fragmentShader);
@@ -170,14 +193,11 @@ bool Shader::compile(const std::string& vertexSrc, const std::string& fragmentSr
glLinkProgram(programId_);
- // Check linking
glGetProgramiv(programId_, GL_LINK_STATUS, &success);
if (!success) {
- GLint logLength;
- glGetProgramiv(programId_, GL_INFO_LOG_LENGTH, &logLength);
- std::string log(logLength, '\0');
- glGetProgramInfoLog(programId_, logLength, nullptr, log.data());
+ std::string log = readProgramInfoLog(programId_);
ES_LOG_ERROR("Shader program linking failed: {}", log);
+ setFailure(ShaderStageFailure::Link, std::move(log));
glDeleteShader(vertexShader);
glDeleteShader(fragmentShader);
glDeleteProgram(programId_);
@@ -185,7 +205,6 @@ bool Shader::compile(const std::string& vertexSrc, const std::string& fragmentSr
return false;
}
- // Clean up shaders (they're now part of the program)
glDeleteShader(vertexShader);
glDeleteShader(fragmentShader);
@@ -196,6 +215,18 @@ bool Shader::compile(const std::string& vertexSrc, const std::string& fragmentSr
return true;
}
+ShaderCompileOutcome Shader::createEx(const std::string& vertexSrc,
+ const std::string& fragmentSrc,
+ std::initializer_list<AttribBinding> bindings) {
+ ShaderCompileOutcome outcome;
+ auto shader = makeUnique<Shader>();
+ if (!shader->compile(vertexSrc, fragmentSrc, bindings, &outcome.log, &outcome.failedStage)) {
+ return outcome;
+ }
+ outcome.shader = std::move(shader);
+ return outcome;
+}
+
namespace {
GfxUniformType shaderUniformTypeFromGL(GLenum type) {
diff --git a/src/esengine/renderer/Shader.hpp b/src/esengine/renderer/Shader.hpp
index 281ea17b2..121f65c86 100644
--- a/src/esengine/renderer/Shader.hpp
+++ b/src/esengine/renderer/Shader.hpp
@@ -34,6 +34,31 @@ struct AttribBinding {
const char* name;
};
+/** @brief Which pipeline stage rejected a shader during compile/link. */
+enum class ShaderStageFailure : u8 {
+ None,
+ Vertex,
+ Fragment,
+ Link,
+};
+
+// Forward declare Shader for the outcome struct.
+class Shader;
+
+/**
+ * @brief Result returned by Shader::createEx when you need the raw driver log.
+ *
+ * On success `shader` is non-null and `failedStage == None`. On failure
+ * `shader` is null, `failedStage` identifies which step rejected the source,
+ * and `log` carries the GL info log verbatim (ready to feed into
+ * ShaderParser::remapCompilerLog).
+ */
+struct ShaderCompileOutcome {
+ Unique<Shader> shader;
+ ShaderStageFailure failedStage = ShaderStageFailure::None;
+ std::string log;
+};
+
// =============================================================================
// Shader Class
// =============================================================================
@@ -95,6 +120,17 @@ public:
*/
static Unique<Shader> createFromFile(const std::string& vertexPath, const std::string& fragmentPath);
+ /**
+ * @brief Creates a shader and exposes the driver log on failure
+ *
+ * Same behaviour as createWithBindings but returns a ShaderCompileOutcome
+ * so callers (notably ShaderLoader) can remap the GL log back to the
+ * original .esshader file and line numbers.
+ */
+ static ShaderCompileOutcome createEx(const std::string& vertexSrc,
+ const std::string& fragmentSrc,
+ std::initializer_list<AttribBinding> bindings = {});
+
// =========================================================================
// Operations
// =========================================================================
@@ -170,7 +206,9 @@ private:
* @return True on success
*/
bool compile(const std::string& vertexSrc, const std::string& fragmentSrc,
- std::initializer_list<AttribBinding> bindings = {});
+ std::initializer_list<AttribBinding> bindings = {},
+ std::string* outLog = nullptr,
+ ShaderStageFailure* outFailedStage = nullptr);
void reflectActiveUniforms();
diff --git a/src/esengine/resource/ShaderParser.cpp b/src/esengine/resource/ShaderParser.cpp
index 2a65f5ee7..c20acd84c 100644
--- a/src/esengine/resource/ShaderParser.cpp
+++ b/src/esengine/resource/ShaderParser.cpp
@@ -283,35 +283,57 @@ ParsedShader ShaderParser::parse(const std::string& source, const ShaderIncludeR
std::string ShaderParser::assembleStage(const ParsedShader& parsed,
ShaderStage stage,
const std::string& platform) {
- if (!parsed.valid) {
- return "";
+ return assembleStageEx(parsed, stage, platform).source;
+}
+
+namespace {
+
+u32 countNewlines(const std::string& s) {
+ u32 n = 0;
+ for (char c : s) {
+ if (c == '\n') ++n;
}
+ return n;
+}
+
+} // namespace
+
+ShaderParser::AssembledStage ShaderParser::assembleStageEx(const ParsedShader& parsed,
+ ShaderStage stage,
+ const std::string& platform) {
+ AssembledStage result;
+
+ if (!parsed.valid) return result;
auto stageIt = parsed.stages.find(stage);
- if (stageIt == parsed.stages.end()) {
- return "";
- }
+ if (stageIt == parsed.stages.end()) return result;
std::ostringstream assembled;
+ u32 headerLines = 0;
if (!parsed.version.empty()) {
assembled << "#version " << parsed.version << "\n";
+ ++headerLines;
}
if (!platform.empty()) {
auto variantIt = parsed.variants.find(platform);
if (variantIt != parsed.variants.end()) {
assembled << variantIt->second;
+ headerLines += countNewlines(variantIt->second);
}
}
if (!parsed.sharedCode.empty()) {
assembled << parsed.sharedCode;
+ headerLines += countNewlines(parsed.sharedCode);
}
assembled << stageIt->second;
- return assembled.str();
+ result.source = assembled.str();
+ result.headerLineCount = headerLines;
+ return result;
}
namespace {
diff --git a/src/esengine/resource/ShaderParser.hpp b/src/esengine/resource/ShaderParser.hpp
index 149462ce9..613aa0232 100644
--- a/src/esengine/resource/ShaderParser.hpp
+++ b/src/esengine/resource/ShaderParser.hpp
@@ -182,6 +182,23 @@ public:
ShaderStage stage,
const std::string& platform = "");
+ /**
+ * @brief Like assembleStage, but also reports the line count of the
+ * assembled prefix (version + variant + sharedCode).
+ *
+ * Stage body starts at output line (headerLineCount + 1); pass
+ * headerLineCount to remapCompilerLog as its `headerLineOffset`
+ * so GL log line numbers can be translated back to the original file.
+ */
+ struct AssembledStage {
+ std::string source;
+ u32 headerLineCount = 0;
+ };
+
+ static AssembledStage assembleStageEx(const ParsedShader& parsed,
+ ShaderStage stage,
+ const std::string& platform = "");
+
/**
* @brief Rewrites GL compile-log line references back to original files
*
diff --git a/src/esengine/resource/loaders/ShaderLoader.cpp b/src/esengine/resource/loaders/ShaderLoader.cpp
index 3ad33ae21..7fec6de87 100644
--- a/src/esengine/resource/loaders/ShaderLoader.cpp
+++ b/src/esengine/resource/loaders/ShaderLoader.cpp
@@ -92,25 +92,53 @@ LoadResult<Shader> ShaderFileLoader::loadFromSource(const std::string& source,
std::string effectivePlatform = platform.empty() ? getDefaultPlatform() : platform;
- std::string vertexSrc = ShaderParser::assembleStage(parsed, ShaderStage::Vertex, effectivePlatform);
- std::string fragmentSrc = ShaderParser::assembleStage(parsed, ShaderStage::Fragment, effectivePlatform);
+ auto vertexAssembled = ShaderParser::assembleStageEx(parsed, ShaderStage::Vertex, effectivePlatform);
+ auto fragmentAssembled = ShaderParser::assembleStageEx(parsed, ShaderStage::Fragment, effectivePlatform);
- if (vertexSrc.empty()) {
+ if (vertexAssembled.source.empty()) {
return LoadResult<Shader>::err("Failed to assemble vertex shader");
}
- if (fragmentSrc.empty()) {
+ if (fragmentAssembled.source.empty()) {
return LoadResult<Shader>::err("Failed to assemble fragment shader");
}
- auto shader = Shader::create(vertexSrc, fragmentSrc);
- if (!shader || !shader->isValid()) {
- ES_LOG_ERROR("ShaderFileLoader: Failed to compile shader");
- return LoadResult<Shader>::err("Failed to compile shader");
+ auto outcome = Shader::createEx(vertexAssembled.source, fragmentAssembled.source);
+ if (!outcome.shader || !outcome.shader->isValid()) {
+ std::string remapped = outcome.log;
+ const char* stageLabel = "unknown";
+ switch (outcome.failedStage) {
+ case ShaderStageFailure::Vertex: {
+ stageLabel = "vertex";
+ auto it = parsed.stageLineMaps.find(ShaderStage::Vertex);
+ if (it != parsed.stageLineMaps.end()) {
+ remapped = ShaderParser::remapCompilerLog(
+ outcome.log, it->second, vertexAssembled.headerLineCount);
+ }
+ break;
+ }
+ case ShaderStageFailure::Fragment: {
+ stageLabel = "fragment";
+ auto it = parsed.stageLineMaps.find(ShaderStage::Fragment);
+ if (it != parsed.stageLineMaps.end()) {
+ remapped = ShaderParser::remapCompilerLog(
+ outcome.log, it->second, fragmentAssembled.headerLineCount);
+ }
+ break;
+ }
+ case ShaderStageFailure::Link:
+ stageLabel = "link";
+ break;
+ case ShaderStageFailure::None:
+ break;
+ }
+ ES_LOG_ERROR("ShaderFileLoader: {} stage failed — {}", stageLabel, remapped);
+ return LoadResult<Shader>::err(
+ std::string{"Shader "} + stageLabel + " stage failed:\n" + remapped);
}
ES_LOG_DEBUG("ShaderFileLoader: Successfully compiled shader '{}'", parsed.name);
- return LoadResult<Shader>::ok(std::move(shader));
+ return LoadResult<Shader>::ok(std::move(outcome.shader));
}
std::string ShaderFileLoader::getDefaultPlatform() {