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

* 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

tools/shaderc/shaderc.cpp

@@ -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)
 			{

tools/shaderc/shaderc.h

@@ -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();
 

tools/shaderc/shaderc_glsl.cpp

@@ -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

tools/shaderc/shaderc_hlsl.cpp

@@ -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;
 	}
 

tools/shaderc/shaderc_metal.cpp

@@ -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

tools/shaderc/shaderc_pssl.cpp

@@ -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;
 	}
 

tools/shaderc/shaderc_spirv.cpp

@@ -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