Mirrors/bgfx
1
0
Fork 0
mirror of https://github.com/bkaradzic/bgfx.git synced 2026-02-17 20:52:36 +01:00
Code Issues Packages Projects Releases Wiki Activity

Write messages to a stream specified by the caller of compilerShader … (#3054)

Browse Source 
* Write messages to a stream specified by the caller of compilerShader rather than directly to stdOut, to allow tool writers to easily capture it.

* PR updates

* Missed a write

* PR updates
This commit is contained in:
Jorge Rodriguez
2023-03-06 10:30:06 -08:00
committed by GitHub
parent f8019cb3d4
commit 70ac58fd38
7 changed files with 205 additions and 183 deletions
Download Patch File Download Diff File Expand all files Collapse all files

126
tools/shaderc/shaderc.cpp
View File

@@ -719,10 +719,11 @@ namespace bgfx
struct Preprocessor
{
Preprocessor(const char* _filePath, bool _essl)
Preprocessor(const char* _filePath, bool _essl, bx::WriterI* _messageWriter)
: m_tagptr(m_tags)
, m_scratchPos(0)
, m_fgetsPos(0)
, m_messageWriter(_messageWriter)
{
m_tagptr->tag = FPPTAG_USERDATA;
m_tagptr->data = this;
@@ -883,9 +884,11 @@ namespace bgfx
thisClass->m_preprocessed += char(_ch);
}
static void fppError(void* /*_userData*/, char* _format, va_list _vargs)
static void fppError(void* _userData, char* _format, va_list _vargs)
{
bx::vprintf(_format, _vargs);
bx::ErrorAssert err;
Preprocessor* thisClass = (Preprocessor*)_userData;
bx::write(thisClass->m_messageWriter, _format, _vargs, &err);
}
char* scratch(const char* _str)
@@ -907,6 +910,7 @@ namespace bgfx
char m_scratch[16<<10];
uint32_t m_scratchPos;
uint32_t m_fgetsPos;
bx::WriterI* m_messageWriter;
};
typedef std::vector<std::string> InOut;
@@ -1071,8 +1075,10 @@ namespace bgfx
return word;
}
bool compileShader(const char* _varying, const char* _comment, char* _shader, uint32_t _shaderLen, Options& _options, bx::WriterI* _writer)
bool compileShader(const char* _varying, const char* _comment, char* _shader, uint32_t _shaderLen, Options& _options, bx::WriterI* _shaderWriter, bx::WriterI* _messageWriter)
{
bx::ErrorAssert messageErr;
uint32_t profile_id = 0;
const char* profile_opt = _options.profile.c_str();
@@ -1098,14 +1104,14 @@ namespace bgfx
if (profile_id == count)
{
bx::printf("Unknown profile: %s\n", profile_opt);
bx::write(_messageWriter, &messageErr, "Unknown profile: %s\n", profile_opt);
return false;
}
}
const Profile *profile = &s_profiles[profile_id];
Preprocessor preprocessor(_options.inputFilePath.c_str(), profile->lang == ShadingLang::ESSL);
Preprocessor preprocessor(_options.inputFilePath.c_str(), profile->lang == ShadingLang::ESSL, _messageWriter);
for (size_t ii = 0; ii < _options.includeDirs.size(); ++ii)
{
@@ -1275,7 +1281,7 @@ namespace bgfx
break;
default:
bx::printf("Unknown type: %c?!", _options.shaderType);
bx::write(_messageWriter, &messageErr, "Unknown type: %c?!", _options.shaderType);
return false;
}
@@ -1460,7 +1466,7 @@ namespace bgfx
if (bx::findIdentifierMatch(it->c_str(), s_allowedVertexShaderInputs).isEmpty() )
{
invalidShaderAttribute = true;
bx::printf(
bx::write(_messageWriter, &messageErr,
"Invalid vertex shader input attribute '%s'.\n"
"\n"
"Valid input attributes:\n"
@@ -1481,49 +1487,49 @@ namespace bgfx
{
if ('f' == _options.shaderType)
{
bx::write(_writer, BGFX_CHUNK_MAGIC_FSH, &err);
bx::write(_shaderWriter, BGFX_CHUNK_MAGIC_FSH, &err);
}
else if ('v' == _options.shaderType)
{
bx::write(_writer, BGFX_CHUNK_MAGIC_VSH, &err);
bx::write(_shaderWriter, BGFX_CHUNK_MAGIC_VSH, &err);
}
else
{
bx::write(_writer, BGFX_CHUNK_MAGIC_CSH, &err);
bx::write(_shaderWriter, BGFX_CHUNK_MAGIC_CSH, &err);
}
bx::write(_writer, inputHash, &err);
bx::write(_writer, outputHash, &err);
bx::write(_shaderWriter, inputHash, &err);
bx::write(_shaderWriter, outputHash, &err);
}
if (raw)
{
if (profile->lang == ShadingLang::GLSL)
{
bx::write(_writer, uint16_t(0), &err);
bx::write(_shaderWriter, uint16_t(0), &err);
uint32_t shaderSize = (uint32_t)bx::strLen(input);
bx::write(_writer, shaderSize, &err);
bx::write(_writer, input, shaderSize, &err);
bx::write(_writer, uint8_t(0), &err);
bx::write(_shaderWriter, shaderSize, &err);
bx::write(_shaderWriter, input, shaderSize, &err);
bx::write(_shaderWriter, uint8_t(0), &err);
compiled = true;
}
else if (profile->lang == ShadingLang::Metal)
{
compiled = compileMetalShader(_options, BX_MAKEFOURCC('M', 'T', 'L', 0), input, _writer);
compiled = compileMetalShader(_options, BX_MAKEFOURCC('M', 'T', 'L', 0), input, _shaderWriter, _messageWriter);
}
else if (profile->lang == ShadingLang::SpirV)
{
compiled = compileSPIRVShader(_options, profile->id, input, _writer);
compiled = compileSPIRVShader(_options, profile->id, input, _shaderWriter, _messageWriter);
}
else if (profile->lang == ShadingLang::PSSL)
{
compiled = compilePSSLShader(_options, 0, input, _writer);
compiled = compilePSSLShader(_options, 0, input, _shaderWriter, _messageWriter);
}
else
{
compiled = compileHLSLShader(_options, profile->id, input, _writer);
compiled = compileHLSLShader(_options, profile->id, input, _shaderWriter, _messageWriter);
}
}
else if ('c' == _options.shaderType) // Compute
@@ -1531,7 +1537,7 @@ namespace bgfx
bx::StringView entry = bx::strFind(input, "void main()");
if (entry.isEmpty() )
{
bx::printf("Shader entry point 'void main()' is not found.\n");
bx::write(_messageWriter, &messageErr, "Shader entry point 'void main()' is not found.\n");
}
else
{
@@ -1618,7 +1624,7 @@ namespace bgfx
if (_options.preprocessOnly)
{
bx::write(
_writer
_shaderWriter
, preprocessor.m_preprocessed.c_str()
, (int32_t)preprocessor.m_preprocessed.size()
, &err
@@ -1630,9 +1636,9 @@ namespace bgfx
{
std::string code;
bx::write(_writer, BGFX_CHUNK_MAGIC_CSH, &err);
bx::write(_writer, uint32_t(0), &err);
bx::write(_writer, outputHash, &err);
bx::write(_shaderWriter, BGFX_CHUNK_MAGIC_CSH, &err);
bx::write(_shaderWriter, uint32_t(0), &err);
bx::write(_shaderWriter, outputHash, &err);
if (profile->lang == ShadingLang::GLSL
|| profile->lang == ShadingLang::ESSL)
@@ -1652,12 +1658,12 @@ namespace bgfx
code += preprocessor.m_preprocessed;
bx::write(_writer, uint16_t(0), &err);
bx::write(_shaderWriter, uint16_t(0), &err);
uint32_t shaderSize = (uint32_t)code.size();
bx::write(_writer, shaderSize, &err);
bx::write(_writer, code.c_str(), shaderSize, &err);
bx::write(_writer, uint8_t(0), &err);
bx::write(_shaderWriter, shaderSize, &err);
bx::write(_shaderWriter, code.c_str(), shaderSize, &err);
bx::write(_shaderWriter, uint8_t(0), &err);
compiled = true;
}
@@ -1668,19 +1674,19 @@ namespace bgfx
if (profile->lang == ShadingLang::Metal)
{
compiled = compileMetalShader(_options, BX_MAKEFOURCC('M', 'T', 'L', 0), code, _writer);
compiled = compileMetalShader(_options, BX_MAKEFOURCC('M', 'T', 'L', 0), code, _shaderWriter, _messageWriter);
}
else if (profile->lang == ShadingLang::SpirV)
{
compiled = compileSPIRVShader(_options, profile->id, code, _writer);
compiled = compileSPIRVShader(_options, profile->id, code, _shaderWriter, _messageWriter);
}
else if (profile->lang == ShadingLang::PSSL)
{
compiled = compilePSSLShader(_options, 0, code, _writer);
compiled = compilePSSLShader(_options, 0, code, _shaderWriter, _messageWriter);
}
else
{
compiled = compileHLSLShader(_options, profile->id, code, _writer);
compiled = compileHLSLShader(_options, profile->id, code, _shaderWriter, _messageWriter);
}
}
}
@@ -1708,7 +1714,7 @@ namespace bgfx
bx::StringView entry = bx::strFind(shader, "void main()");
if (entry.isEmpty() )
{
bx::printf("Shader entry point 'void main()' is not found.\n");
bx::write(_messageWriter, &messageErr, "Shader entry point 'void main()' is not found.\n");
}
else
{
@@ -1959,7 +1965,7 @@ namespace bgfx
}
else
{
bx::printf("gl_PrimitiveID builtin is not supported by D3D9 HLSL.\n");
bx::write(_messageWriter, &messageErr, "gl_PrimitiveID builtin is not supported by D3D9 HLSL.\n");
return false;
}
}
@@ -2034,7 +2040,7 @@ namespace bgfx
}
else
{
bx::printf("gl_ViewportIndex builtin is not supported by D3D9 HLSL.\n");
bx::write(_messageWriter, &messageErr, "gl_ViewportIndex builtin is not supported by D3D9 HLSL.\n");
return false;
}
}
@@ -2050,7 +2056,7 @@ namespace bgfx
}
else
{
bx::printf("gl_Layer builtin is not supported by D3D9 HLSL.\n");
bx::write(_messageWriter, &messageErr, "gl_Layer builtin is not supported by D3D9 HLSL.\n");
return false;
}
}
@@ -2089,7 +2095,7 @@ namespace bgfx
}
else
{
bx::printf("gl_VertexID builtin is not supported by D3D9 HLSL.\n");
bx::write(_messageWriter, &messageErr, "gl_VertexID builtin is not supported by D3D9 HLSL.\n");
return false;
}
}
@@ -2105,7 +2111,7 @@ namespace bgfx
}
else
{
bx::printf("gl_InstanceID builtin is not supported by D3D9 HLSL.\n");
bx::write(_messageWriter, &messageErr, "gl_InstanceID builtin is not supported by D3D9 HLSL.\n");
return false;
}
}
@@ -2147,7 +2153,7 @@ namespace bgfx
if (_options.preprocessOnly)
{
bx::write(
_writer
_shaderWriter
, preprocessor.m_preprocessed.c_str()
, (int32_t)preprocessor.m_preprocessed.size()
, &err
@@ -2161,21 +2167,21 @@ namespace bgfx
if ('f' == _options.shaderType)
{
bx::write(_writer, BGFX_CHUNK_MAGIC_FSH, &err);
bx::write(_writer, inputHash, &err);
bx::write(_writer, uint32_t(0), &err);
bx::write(_shaderWriter, BGFX_CHUNK_MAGIC_FSH, &err);
bx::write(_shaderWriter, inputHash, &err);
bx::write(_shaderWriter, uint32_t(0), &err);
}
else if ('v' == _options.shaderType)
{
bx::write(_writer, BGFX_CHUNK_MAGIC_VSH, &err);
bx::write(_writer, uint32_t(0), &err);
bx::write(_writer, outputHash, &err);
bx::write(_shaderWriter, BGFX_CHUNK_MAGIC_VSH, &err);
bx::write(_shaderWriter, uint32_t(0), &err);
bx::write(_shaderWriter, outputHash, &err);
}
else
{
bx::write(_writer, BGFX_CHUNK_MAGIC_CSH, &err);
bx::write(_writer, uint32_t(0), &err);
bx::write(_writer, outputHash, &err);
bx::write(_shaderWriter, BGFX_CHUNK_MAGIC_CSH, &err);
bx::write(_shaderWriter, uint32_t(0), &err);
bx::write(_shaderWriter, outputHash, &err);
}
if (profile->lang == ShadingLang::GLSL
@@ -2538,12 +2544,12 @@ namespace bgfx
{
code += preprocessor.m_preprocessed;
bx::write(_writer, uint16_t(0), &err);
bx::write(_shaderWriter, uint16_t(0), &err);
uint32_t shaderSize = (uint32_t)code.size();
bx::write(_writer, shaderSize, &err);
bx::write(_writer, code.c_str(), shaderSize, &err);
bx::write(_writer, uint8_t(0), &err);
bx::write(_shaderWriter, shaderSize, &err);
bx::write(_shaderWriter, code.c_str(), shaderSize, &err);
bx::write(_shaderWriter, uint8_t(0), &err);
compiled = true;
}
@@ -2557,7 +2563,7 @@ namespace bgfx
glsl_profile |= 0x80000000;
}
compiled = compileGLSLShader(_options, glsl_profile, code, _writer);
compiled = compileGLSLShader(_options, glsl_profile, code, _shaderWriter, _messageWriter);
}
}
else
@@ -2567,19 +2573,19 @@ namespace bgfx
if (profile->lang == ShadingLang::Metal)
{
compiled = compileMetalShader(_options, BX_MAKEFOURCC('M', 'T', 'L', 0), code, _writer);
compiled = compileMetalShader(_options, BX_MAKEFOURCC('M', 'T', 'L', 0), code, _shaderWriter, _messageWriter);
}
else if (profile->lang == ShadingLang::SpirV)
{
compiled = compileSPIRVShader(_options, profile->id, code, _writer);
compiled = compileSPIRVShader(_options, profile->id, code, _shaderWriter, _messageWriter);
}
else if (profile->lang == ShadingLang::PSSL)
{
compiled = compilePSSLShader(_options, 0, code, _writer);
compiled = compilePSSLShader(_options, 0, code, _shaderWriter, _messageWriter);
}
else
{
compiled = compileHLSLShader(_options, profile->id, code, _writer);
compiled = compileHLSLShader(_options, profile->id, code, _shaderWriter, _messageWriter);
}
}
}
@@ -2837,7 +2843,7 @@ namespace bgfx
}
}
compiled = compileShader(varying, commandLineComment.c_str(), data, size, options, consoleOut ? bx::getStdOut() : writer);
compiled = compileShader(varying, commandLineComment.c_str(), data, size, options, consoleOut ? bx::getStdOut() : writer, bx::getStdOut());
if (!consoleOut)
{

10
tools/shaderc/shaderc.h
View File

@@ -119,11 +119,11 @@ namespace bgfx
int32_t writef(bx::WriterI* _writer, const char* _format, ...);
void writeFile(const char* _filePath, const void* _data, int32_t _size);
bool compileGLSLShader(const Options& _options, uint32_t _version, const std::string& _code, bx::WriterI* _writer);
bool compileHLSLShader(const Options& _options, uint32_t _version, const std::string& _code, bx::WriterI* _writer);
bool compileMetalShader(const Options& _options, uint32_t _version, const std::string& _code, bx::WriterI* _writer);
bool compilePSSLShader(const Options& _options, uint32_t _version, const std::string& _code, bx::WriterI* _writer);
bool compileSPIRVShader(const Options& _options, uint32_t _version, const std::string& _code, bx::WriterI* _writer);
bool compileGLSLShader(const Options& _options, uint32_t _version, const std::string& _code, bx::WriterI* _writer, bx::WriterI* _messages);
bool compileHLSLShader(const Options& _options, uint32_t _version, const std::string& _code, bx::WriterI* _writer, bx::WriterI* _messages);
bool compileMetalShader(const Options& _options, uint32_t _version, const std::string& _code, bx::WriterI* _writer, bx::WriterI* _messages);
bool compilePSSLShader(const Options& _options, uint32_t _version, const std::string& _code, bx::WriterI* _writer, bx::WriterI* _messages);
bool compileSPIRVShader(const Options& _options, uint32_t _version, const std::string& _code, bx::WriterI* _writer, bx::WriterI* _messages);
const char* getPsslPreamble();

36
tools/shaderc/shaderc_glsl.cpp
View File

@@ -8,8 +8,10 @@
namespace bgfx { namespace glsl
{
static bool compile(const Options& _options, uint32_t _version, const std::string& _code, bx::WriterI* _writer)
static bool compile(const Options& _options, uint32_t _version, const std::string& _code, bx::WriterI* _shaderWriter, bx::WriterI* _messageWriter)
{
bx::ErrorAssert messageErr;
char ch = _options.shaderType;
const glslopt_shader_type type = ch == 'f'
? kGlslOptShaderFragment
@@ -53,7 +55,7 @@ namespace bgfx { namespace glsl
}
printCode(_code.c_str(), line, start, end, column);
bx::printf("Error: %s\n", log);
bx::write(_messageWriter, &messageErr, "Error: %s\n", log);
glslopt_shader_delete(shader);
glslopt_cleanup(ctx);
return false;
@@ -348,22 +350,22 @@ namespace bgfx { namespace glsl
bx::ErrorAssert err;
uint16_t count = (uint16_t)uniforms.size();
bx::write(_writer, count, &err);
bx::write(_shaderWriter, count, &err);
for (UniformArray::const_iterator it = uniforms.begin(); it != uniforms.end(); ++it)
{
const Uniform& un = *it;
uint8_t nameSize = (uint8_t)un.name.size();
bx::write(_writer, nameSize, &err);
bx::write(_writer, un.name.c_str(), nameSize, &err);
bx::write(_shaderWriter, nameSize, &err);
bx::write(_shaderWriter, un.name.c_str(), nameSize, &err);
uint8_t uniformType = uint8_t(un.type);
bx::write(_writer, uniformType, &err);
bx::write(_writer, un.num, &err);
bx::write(_writer, un.regIndex, &err);
bx::write(_writer, un.regCount, &err);
bx::write(_writer, un.texComponent, &err);
bx::write(_writer, un.texDimension, &err);
bx::write(_writer, un.texFormat, &err);
bx::write(_shaderWriter, uniformType, &err);
bx::write(_shaderWriter, un.num, &err);
bx::write(_shaderWriter, un.regIndex, &err);
bx::write(_shaderWriter, un.regCount, &err);
bx::write(_shaderWriter, un.texComponent, &err);
bx::write(_shaderWriter, un.texDimension, &err);
bx::write(_shaderWriter, un.texFormat, &err);
BX_TRACE("%s, %s, %d, %d, %d"
, un.name.c_str()
@@ -375,10 +377,10 @@ namespace bgfx { namespace glsl
}
uint32_t shaderSize = (uint32_t)bx::strLen(optimizedShader);
bx::write(_writer, shaderSize, &err);
bx::write(_writer, optimizedShader, shaderSize, &err);
bx::write(_shaderWriter, shaderSize, &err);
bx::write(_shaderWriter, optimizedShader, shaderSize, &err);
uint8_t nul = 0;
bx::write(_writer, nul, &err);
bx::write(_shaderWriter, nul, &err);
if (_options.disasm )
{
@@ -394,9 +396,9 @@ namespace bgfx { namespace glsl
} // namespace glsl
bool compileGLSLShader(const Options& _options, uint32_t _version, const std::string& _code, bx::WriterI* _writer)
bool compileGLSLShader(const Options& _options, uint32_t _version, const std::string& _code, bx::WriterI* _shaderWriter, bx::WriterI* _messageWriter)
{
return glsl::compile(_options, _version, _code, _writer);
return glsl::compile(_options, _version, _code, _shaderWriter, _messageWriter);
}
} // namespace bgfx

85
tools/shaderc/shaderc_hlsl.cpp
View File

@@ -80,8 +80,10 @@ namespace bgfx { namespace hlsl
static const D3DCompiler* s_compiler;
static void* s_d3dcompilerdll;
const D3DCompiler* load()
const D3DCompiler* load(bx::WriterI* _messageWriter)
{
bx::Error messageErr;
for (uint32_t ii = 0; ii < BX_COUNTOF(s_d3dcompiler); ++ii)
{
const D3DCompiler* compiler = &s_d3dcompiler[ii];
@@ -115,7 +117,7 @@ namespace bgfx { namespace hlsl
return compiler;
}
bx::printf("Error: Unable to open D3DCompiler_*.dll shader compiler.\n");
bx::write(_messageWriter, &messageErr, "Error: Unable to open D3DCompiler_*.dll shader compiler.\n");
return NULL;
}
@@ -276,8 +278,10 @@ namespace bgfx { namespace hlsl
return false;
}
bool getReflectionDataD3D9(ID3DBlob* _code, UniformArray& _uniforms)
bool getReflectionDataD3D9(ID3DBlob* _code, UniformArray& _uniforms, bx::WriterI* _messageWriter)
{
bx::ErrorAssert messageErr;
// see reference for magic values: https://msdn.microsoft.com/en-us/library/ff552891(VS.85).aspx
const uint32_t D3DSIO_COMMENT = 0x0000FFFE;
const uint32_t D3DSIO_END = 0x0000FFFF;
@@ -311,7 +315,7 @@ namespace bgfx { namespace hlsl
uint32_t tableSize = (commentSize - 1) * 4;
if (tableSize < sizeof(CTHeader) || header->Size != sizeof(CTHeader) )
{
bx::printf("Error: Invalid constant table data\n");
bx::write(_messageWriter, &messageErr, "Error: Invalid constant table data\n");
return false;
}
break;
@@ -323,7 +327,7 @@ namespace bgfx { namespace hlsl
if (!header)
{
bx::printf("Error: Could not find constant table data\n");
bx::write(_messageWriter, &messageErr, "Error: Could not find constant table data\n");
return false;
}
@@ -381,8 +385,10 @@ namespace bgfx { namespace hlsl
return true;
}
bool getReflectionDataD3D11(ID3DBlob* _code, bool _vshader, UniformArray& _uniforms, uint8_t& _numAttrs, uint16_t* _attrs, uint16_t& _size, UniformNameList& unusedUniforms)
bool getReflectionDataD3D11(ID3DBlob* _code, bool _vshader, UniformArray& _uniforms, uint8_t& _numAttrs, uint16_t* _attrs, uint16_t& _size, UniformNameList& unusedUniforms, bx::WriterI* _messageWriter)
{
bx::Error messageErr;
ID3D11ShaderReflection* reflect = NULL;
HRESULT hr = D3DReflect(_code->GetBufferPointer()
, _code->GetBufferSize()
@@ -391,7 +397,7 @@ namespace bgfx { namespace hlsl
);
if (FAILED(hr) )
{
bx::printf("Error: D3DReflect failed 0x%08x\n", (uint32_t)hr);
bx::write(_messageWriter, &messageErr, "Error: D3DReflect failed 0x%08x\n", (uint32_t)hr);
return false;
}
@@ -399,7 +405,7 @@ namespace bgfx { namespace hlsl
hr = reflect->GetDesc(&desc);
if (FAILED(hr) )
{
bx::printf("Error: ID3D11ShaderReflection::GetDesc failed 0x%08x\n", (uint32_t)hr);
bx::write(_messageWriter, &messageErr, "Error: ID3D11ShaderReflection::GetDesc failed 0x%08x\n", (uint32_t)hr);
return false;
}
@@ -553,13 +559,15 @@ namespace bgfx { namespace hlsl
return true;
}
static bool compile(const Options& _options, uint32_t _version, const std::string& _code, bx::WriterI* _writer, bool _firstPass)
static bool compile(const Options& _options, uint32_t _version, const std::string& _code, bx::WriterI* _shaderWriter, bx::WriterI* _messageWriter, bool _firstPass)
{
bx::Error messageErr;
const char* profile = _options.profile.c_str();
if (profile[0] == '\0')
{
bx::printf("Error: Shader profile must be specified.\n");
bx::write(_messageWriter, &messageErr, "Error: Shader profile must be specified.\n");
return false;
}
@@ -567,7 +575,7 @@ namespace bgfx { namespace hlsl
profileAndType[0] = (_options.shaderType == 'f') ? 'p' : _options.shaderType;
bx::strCat(profileAndType, BX_COUNTOF(profileAndType), profile);
s_compiler = load();
s_compiler = load(_messageWriter);
bool result = false;
bool debug = _options.debugInformation;
@@ -660,7 +668,7 @@ namespace bgfx { namespace hlsl
}
printCode(_code.c_str(), line, start, end, column);
bx::printf("Error: D3DCompile failed 0x%08x %s\n", (uint32_t)hr, log);
bx::write(_messageWriter, &messageErr, "Error: D3DCompile failed 0x%08x %s\n", (uint32_t)hr, log);
errorMsg->Release();
return false;
}
@@ -672,18 +680,18 @@ namespace bgfx { namespace hlsl
if (_version < 400)
{
if (!getReflectionDataD3D9(code, uniforms) )
if (!getReflectionDataD3D9(code, uniforms, _messageWriter) )
{
bx::printf("Error: Unable to get D3D9 reflection data.\n");
bx::write(_messageWriter, &messageErr, "Error: Unable to get D3D9 reflection data.\n");
goto error;
}
}
else
{
UniformNameList unusedUniforms;
if (!getReflectionDataD3D11(code, profileAndType[0] == 'v', uniforms, numAttrs, attrs, size, unusedUniforms) )
if (!getReflectionDataD3D11(code, profileAndType[0] == 'v', uniforms, numAttrs, attrs, size, unusedUniforms, _messageWriter) )
{
bx::printf("Error: Unable to get D3D11 reflection data.\n");
bx::write(_messageWriter, &messageErr, "Error: Unable to get D3D11 reflection data.\n");
goto error;
}
@@ -732,29 +740,29 @@ namespace bgfx { namespace hlsl
}
// recompile with the unused uniforms converted to statics
return compile(_options, _version, output.c_str(), _writer, false);
return compile(_options, _version, output.c_str(), _shaderWriter, _messageWriter, false);
}
}
{
uint16_t count = (uint16_t)uniforms.size();
bx::write(_writer, count, &err);
bx::write(_shaderWriter, count, &err);
uint32_t fragmentBit = profileAndType[0] == 'p' ? kUniformFragmentBit : 0;
for (UniformArray::const_iterator it = uniforms.begin(); it != uniforms.end(); ++it)
{
const Uniform& un = *it;
uint8_t nameSize = (uint8_t)un.name.size();
bx::write(_writer, nameSize, &err);
bx::write(_writer, un.name.c_str(), nameSize, &err);
bx::write(_shaderWriter, nameSize, &err);
bx::write(_shaderWriter, un.name.c_str(), nameSize, &err);
uint8_t type = uint8_t(un.type | fragmentBit);
bx::write(_writer, type, &err);
bx::write(_writer, un.num, &err);
bx::write(_writer, un.regIndex, &err);
bx::write(_writer, un.regCount, &err);
bx::write(_writer, un.texComponent, &err);
bx::write(_writer, un.texDimension, &err);
bx::write(_writer, un.texFormat, &err);
bx::write(_shaderWriter, type, &err);
bx::write(_shaderWriter, un.num, &err);
bx::write(_shaderWriter, un.regIndex, &err);
bx::write(_shaderWriter, un.regCount, &err);
bx::write(_shaderWriter, un.texComponent, &err);
bx::write(_shaderWriter, un.texDimension, &err);
bx::write(_shaderWriter, un.texFormat, &err);
BX_TRACE("%s, %s, %d, %d, %d"
, un.name.c_str()
@@ -784,18 +792,18 @@ namespace bgfx { namespace hlsl
{
uint32_t shaderSize = uint32_t(code->GetBufferSize() );
bx::write(_writer, shaderSize, &err);
bx::write(_writer, code->GetBufferPointer(), shaderSize, &err);
bx::write(_shaderWriter, shaderSize, &err);
bx::write(_shaderWriter, code->GetBufferPointer(), shaderSize, &err);
uint8_t nul = 0;
bx::write(_writer, nul, &err);
bx::write(_shaderWriter, nul, &err);
}
if (_version >= 400)
{
bx::write(_writer, numAttrs, &err);
bx::write(_writer, attrs, numAttrs*sizeof(uint16_t), &err);
bx::write(_shaderWriter, numAttrs, &err);
bx::write(_shaderWriter, attrs, numAttrs*sizeof(uint16_t), &err);
bx::write(_writer, size, &err);
bx::write(_shaderWriter, size, &err);
}
if (_options.disasm )
@@ -832,9 +840,9 @@ namespace bgfx { namespace hlsl
} // namespace hlsl
bool compileHLSLShader(const Options& _options, uint32_t _version, const std::string& _code, bx::WriterI* _writer)
bool compileHLSLShader(const Options& _options, uint32_t _version, const std::string& _code, bx::WriterI* _shaderWriter, bx::WriterI* _messageWriter)
{
return hlsl::compile(_options, _version, _code, _writer, true);
return hlsl::compile(_options, _version, _code, _shaderWriter, _messageWriter, true);
}
} // namespace bgfx
@@ -843,10 +851,11 @@ namespace bgfx { namespace hlsl
namespace bgfx
{
bool compileHLSLShader(const Options& _options, uint32_t _version, const std::string& _code, bx::WriterI* _writer)
bool compileHLSLShader(const Options& _options, uint32_t _version, const std::string& _code, bx::WriterI* _shaderWriter, bx::WriterI* _messageWriter)
{
BX_UNUSED(_options, _version, _code, _writer);
bx::printf("HLSL compiler is not supported on this platform.\n");
BX_UNUSED(_options, _version, _code, _shaderWriter);
bx::Error messageErr;
bx::write(_messageWriter, &messageErr, "HLSL compiler is not supported on this platform.\n");
return false;
}

66
tools/shaderc/shaderc_metal.cpp
View File

@@ -225,14 +225,14 @@ namespace bgfx { namespace metal
"BgfxSampler2DMS",
};
static uint16_t writeUniformArray(bx::WriterI* _writer, const UniformArray& uniforms, bool isFragmentShader)
static uint16_t writeUniformArray(bx::WriterI* _shaderWriter, const UniformArray& uniforms, bool isFragmentShader)
{
uint16_t size = 0;
bx::ErrorAssert err;
uint16_t count = uint16_t(uniforms.size());
bx::write(_writer, count, &err);
bx::write(_shaderWriter, count, &err);
uint32_t fragmentBit = isFragmentShader ? kUniformFragmentBit : 0;
for (uint16_t ii = 0; ii < count; ++ii)
@@ -242,15 +242,15 @@ namespace bgfx { namespace metal
size += un.regCount*16;
uint8_t nameSize = (uint8_t)un.name.size();
bx::write(_writer, nameSize, &err);
bx::write(_writer, un.name.c_str(), nameSize, &err);
bx::write(_writer, uint8_t(un.type | fragmentBit), &err);
bx::write(_writer, un.num, &err);
bx::write(_writer, un.regIndex, &err);
bx::write(_writer, un.regCount, &err);
bx::write(_writer, un.texComponent, &err);
bx::write(_writer, un.texDimension, &err);
bx::write(_writer, un.texFormat, &err);
bx::write(_shaderWriter, nameSize, &err);
bx::write(_shaderWriter, un.name.c_str(), nameSize, &err);
bx::write(_shaderWriter, uint8_t(un.type | fragmentBit), &err);
bx::write(_shaderWriter, un.num, &err);
bx::write(_shaderWriter, un.regIndex, &err);
bx::write(_shaderWriter, un.regCount, &err);
bx::write(_shaderWriter, un.texComponent, &err);
bx::write(_shaderWriter, un.texDimension, &err);
bx::write(_shaderWriter, un.texFormat, &err);
BX_TRACE("%s, %s, %d, %d, %d"
, un.name.c_str()
@@ -263,16 +263,18 @@ namespace bgfx { namespace metal
return size;
}
static bool compile(const Options& _options, uint32_t _version, const std::string& _code, bx::WriterI* _writer, bool _firstPass)
static bool compile(const Options& _options, uint32_t _version, const std::string& _code, bx::WriterI* _shaderWriter, bx::WriterI* _messageWriter, bool _firstPass)
{
BX_UNUSED(_version);
bx::ErrorAssert messageErr;
glslang::InitializeProcess();
EShLanguage stage = getLang(_options.shaderType);
if (EShLangCount == stage)
{
bx::printf("Error: Unknown shader type '%c'.\n", _options.shaderType);
bx::write(_messageWriter, &messageErr, "Error: Unknown shader type '%c'.\n", _options.shaderType);
return false;
}
@@ -338,7 +340,7 @@ namespace bgfx { namespace metal
printCode(_code.c_str(), line, start, end, column);
bx::printf("%s\n", log);
bx::write(_messageWriter, &messageErr, "%s\n", log);
}
}
else
@@ -354,7 +356,7 @@ namespace bgfx { namespace metal
const char* log = program->getInfoLog();
if (NULL != log)
{
bx::printf("%s\n", log);
bx::write(_messageWriter, &messageErr, "%s\n", log);
}
}
else
@@ -434,7 +436,7 @@ namespace bgfx { namespace metal
// recompile with the unused uniforms converted to statics
delete program;
delete shader;
return compile(_options, _version, output.c_str(), _writer, false);
return compile(_options, _version, output.c_str(), _shaderWriter, _messageWriter, false);
}
UniformArray uniforms;
@@ -498,14 +500,14 @@ namespace bgfx { namespace metal
spvtools::Optimizer opt(SPV_ENV_VULKAN_1_0);
auto print_msg_to_stderr = [](
auto print_msg_to_stderr = [_messageWriter, &messageErr](
spv_message_level_t
, const char*
, const spv_position_t&
, const char* m
)
{
bx::printf("Error: %s\n", m);
bx::write(_messageWriter, &messageErr, "Error: %s\n", m);
};
opt.SetMessageConsumer(print_msg_to_stderr);
@@ -554,7 +556,7 @@ namespace bgfx { namespace metal
uniforms.push_back(un);
}
uint16_t size = writeUniformArray( _writer, uniforms, _options.shaderType == 'f');
uint16_t size = writeUniformArray(_shaderWriter, uniforms, _options.shaderType == 'f');
bx::Error err;
@@ -642,42 +644,42 @@ namespace bgfx { namespace metal
for (int i = 0; i < 3; ++i)
{
uint16_t dim = (uint16_t)msl.get_execution_mode_argument(spv::ExecutionMode::ExecutionModeLocalSize, i);
bx::write(_writer, dim, &err);
bx::write(_shaderWriter, dim, &err);
}
}
uint32_t shaderSize = (uint32_t)source.size();
bx::write(_writer, shaderSize, &err);
bx::write(_writer, source.c_str(), shaderSize, &err);
bx::write(_shaderWriter, shaderSize, &err);
bx::write(_shaderWriter, source.c_str(), shaderSize, &err);
uint8_t nul = 0;
bx::write(_writer, nul, &err);
bx::write(_shaderWriter, nul, &err);
}
else
{
uint32_t shaderSize = (uint32_t)spirv.size() * sizeof(uint32_t);
bx::write(_writer, shaderSize, &err);
bx::write(_writer, spirv.data(), shaderSize, &err);
bx::write(_shaderWriter, shaderSize, &err);
bx::write(_shaderWriter, spirv.data(), shaderSize, &err);
uint8_t nul = 0;
bx::write(_writer, nul, &err);
bx::write(_shaderWriter, nul, &err);
}
//
const uint8_t numAttr = (uint8_t)program->getNumLiveAttributes();
bx::write(_writer, numAttr, &err);
bx::write(_shaderWriter, numAttr, &err);
for (uint8_t ii = 0; ii < numAttr; ++ii)
{
bgfx::Attrib::Enum attr = toAttribEnum(program->getAttributeName(ii) );
if (bgfx::Attrib::Count != attr)
{
bx::write(_writer, bgfx::attribToId(attr), &err);
bx::write(_shaderWriter, bgfx::attribToId(attr), &err);
}
else
{
bx::write(_writer, uint16_t(UINT16_MAX), &err);
bx::write(_shaderWriter, uint16_t(UINT16_MAX), &err);
}
}
bx::write(_writer, size, &err);
bx::write(_shaderWriter, size, &err);
}
}
}
@@ -692,9 +694,9 @@ namespace bgfx { namespace metal
} // namespace metal
bool compileMetalShader(const Options& _options, uint32_t _version, const std::string& _code, bx::WriterI* _writer)
bool compileMetalShader(const Options& _options, uint32_t _version, const std::string& _code, bx::WriterI* _shaderWriter, bx::WriterI* _messageWriter)
{
return metal::compile(_options, _version, _code, _writer, true);
return metal::compile(_options, _version, _code, _shaderWriter, _messageWriter, true);
}
} // namespace bgfx

7
tools/shaderc/shaderc_pssl.cpp
View File

@@ -7,10 +7,11 @@
namespace bgfx
{
bool compilePSSLShader(const Options& _options, uint32_t _version, const std::string& _code, bx::WriterI* _writer)
bool compilePSSLShader(const Options& _options, uint32_t _version, const std::string& _code, bx::WriterI* _shaderWriter, bx::WriterI* _messageWriter)
{
BX_UNUSED(_options, _version, _code, _writer);
bx::printf("PSSL compiler is not supported.\n");
BX_UNUSED(_options, _version, _code, _shaderWriter);
bx::ErrorAssert messageErr;
bx::write(_messageWriter, &messageErr, "PSSL compiler is not supported.\n");
return false;
}

58
tools/shaderc/shaderc_spirv.cpp
View File

@@ -331,14 +331,14 @@ namespace bgfx { namespace spirv
"BgfxSampler2DMS",
};
static uint16_t writeUniformArray(bx::WriterI* _writer, const UniformArray& uniforms, bool isFragmentShader)
static uint16_t writeUniformArray(bx::WriterI* _shaderWriter, const UniformArray& uniforms, bool isFragmentShader)
{
uint16_t size = 0;
bx::ErrorAssert err;
uint16_t count = uint16_t(uniforms.size());
bx::write(_writer, count, &err);
bx::write(_shaderWriter, count, &err);
uint32_t fragmentBit = isFragmentShader ? kUniformFragmentBit : 0;
@@ -352,15 +352,15 @@ namespace bgfx { namespace spirv
}
uint8_t nameSize = (uint8_t)un.name.size();
bx::write(_writer, nameSize, &err);
bx::write(_writer, un.name.c_str(), nameSize, &err);
bx::write(_writer, uint8_t(un.type | fragmentBit), &err);
bx::write(_writer, un.num, &err);
bx::write(_writer, un.regIndex, &err);
bx::write(_writer, un.regCount, &err);
bx::write(_writer, un.texComponent, &err);
bx::write(_writer, un.texDimension, &err);
bx::write(_writer, un.texFormat, &err);
bx::write(_shaderWriter, nameSize, &err);
bx::write(_shaderWriter, un.name.c_str(), nameSize, &err);
bx::write(_shaderWriter, uint8_t(un.type | fragmentBit), &err);
bx::write(_shaderWriter, un.num, &err);
bx::write(_shaderWriter, un.regIndex, &err);
bx::write(_shaderWriter, un.regCount, &err);
bx::write(_shaderWriter, un.texComponent, &err);
bx::write(_shaderWriter, un.texDimension, &err);
bx::write(_shaderWriter, un.texFormat, &err);
BX_TRACE("%s, %s, %d, %d, %d"
, un.name.c_str()
@@ -438,16 +438,18 @@ namespace bgfx { namespace spirv
/// The value is 100.
constexpr int s_GLSL_VULKAN_CLIENT_VERSION = 100;
static bool compile(const Options& _options, uint32_t _version, const std::string& _code, bx::WriterI* _writer, bool _firstPass)
static bool compile(const Options& _options, uint32_t _version, const std::string& _code, bx::WriterI* _shaderWriter, bx::WriterI* _messageWriter, bool _firstPass)
{
BX_UNUSED(_version);
bx::ErrorAssert messageErr;
glslang::InitializeProcess();
EShLanguage stage = getLang(_options.shaderType);
if (EShLangCount == stage)
{
bx::printf("Error: Unknown shader type '%c'.\n", _options.shaderType);
bx::write(_messageWriter, &messageErr, "Error: Unknown shader type '%c'.\n", _options.shaderType);
return false;
}
@@ -519,7 +521,7 @@ namespace bgfx { namespace spirv
printCode(_code.c_str(), line, start, end, column);
bx::printf("%s\n", log);
bx::write(_messageWriter, &messageErr, "%s\n", log);
}
}
else
@@ -535,7 +537,7 @@ namespace bgfx { namespace spirv
const char* log = program->getInfoLog();
if (NULL != log)
{
bx::printf("%s\n", log);
bx::write(_messageWriter, &messageErr, "%s\n", log);
}
}
else
@@ -640,7 +642,7 @@ namespace bgfx { namespace spirv
// recompile with the unused uniforms converted to statics
delete program;
delete shader;
return compile(_options, _version, output.c_str(), _writer, false);
return compile(_options, _version, output.c_str(), _shaderWriter, _messageWriter, false);
}
UniformArray uniforms;
@@ -708,14 +710,14 @@ namespace bgfx { namespace spirv
spvtools::Optimizer opt(getSpirvTargetVersion(_version));
auto print_msg_to_stderr = [](
auto print_msg_to_stderr = [_messageWriter, &messageErr](
spv_message_level_t
, const char*
, const spv_position_t&
, const char* m
)
{
bx::printf("Error: %s\n", m);
bx::write(_messageWriter, &messageErr, "Error: %s\n", m);
};
opt.SetMessageConsumer(print_msg_to_stderr);
@@ -842,31 +844,31 @@ namespace bgfx { namespace spirv
uniforms.push_back(un);
}
uint16_t size = writeUniformArray( _writer, uniforms, _options.shaderType == 'f');
uint16_t size = writeUniformArray(_shaderWriter, uniforms, _options.shaderType == 'f');
uint32_t shaderSize = (uint32_t)spirv.size() * sizeof(uint32_t);
bx::write(_writer, shaderSize, &err);
bx::write(_writer, spirv.data(), shaderSize, &err);
bx::write(_shaderWriter, shaderSize, &err);
bx::write(_shaderWriter, spirv.data(), shaderSize, &err);
uint8_t nul = 0;
bx::write(_writer, nul, &err);
bx::write(_shaderWriter, nul, &err);
const uint8_t numAttr = (uint8_t)program->getNumLiveAttributes();
bx::write(_writer, numAttr, &err);
bx::write(_shaderWriter, numAttr, &err);
for (uint8_t ii = 0; ii < numAttr; ++ii)
{
bgfx::Attrib::Enum attr = toAttribEnum(program->getAttributeName(ii) );
if (bgfx::Attrib::Count != attr)
{
bx::write(_writer, bgfx::attribToId(attr), &err);
bx::write(_shaderWriter, bgfx::attribToId(attr), &err);
}
else
{
bx::write(_writer, uint16_t(UINT16_MAX), &err);
bx::write(_shaderWriter, uint16_t(UINT16_MAX), &err);
}
}
bx::write(_writer, size, &err);
bx::write(_shaderWriter, size, &err);
}
}
}
@@ -881,9 +883,9 @@ namespace bgfx { namespace spirv
} // namespace spirv
bool compileSPIRVShader(const Options& _options, uint32_t _version, const std::string& _code, bx::WriterI* _writer)
bool compileSPIRVShader(const Options& _options, uint32_t _version, const std::string& _code, bx::WriterI* _shaderWriter, bx::WriterI* _messageWriter)
{
return spirv::compile(_options, _version, _code, _writer, true);
return spirv::compile(_options, _version, _code, _shaderWriter, _messageWriter, true);
}
} // namespace bgfx