Fixed assert macros, and improved error handling.

examples/13-stencil/stencil.cpp

@@ -15,7 +15,7 @@
 
 namespace bgfx
 {
-	int32_t read(bx::ReaderI* _reader, bgfx::VertexLayout& _layout, bx::Error* _err = NULL);
+	int32_t read(bx::ReaderI* _reader, bgfx::VertexLayout& _layout, bx::Error* _err);
 }
 
 namespace
@@ -650,24 +650,26 @@ struct Mesh
 
 		Group group;
 
+		bx::Error err;
+
 		uint32_t chunk;
-		while (4 == bx::read(reader, chunk) )
+		while (4 == bx::read(reader, chunk, &err) )
 		{
 			switch (chunk)
 			{
 			case BGFX_CHUNK_MAGIC_VB:
 				{
-					bx::read(reader, group.m_sphere);
-					bx::read(reader, group.m_aabb);
-					bx::read(reader, group.m_obb);
+					bx::read(reader, group.m_sphere, &err);
+					bx::read(reader, group.m_aabb, &err);
+					bx::read(reader, group.m_obb, &err);
 
-					bgfx::read(reader, m_layout);
+					bgfx::read(reader, m_layout, &err);
 					uint16_t stride = m_layout.getStride();
 
 					uint16_t numVertices;
-					bx::read(reader, numVertices);
+					bx::read(reader, numVertices, &err);
 					const bgfx::Memory* mem = bgfx::alloc(numVertices*stride);
-					bx::read(reader, mem->data, mem->size);
+					bx::read(reader, mem->data, mem->size, &err);
 
 					group.m_vbh = bgfx::createVertexBuffer(mem, m_layout);
 				}
@@ -676,9 +678,9 @@ struct Mesh
 			case BGFX_CHUNK_MAGIC_IB:
 				{
 					uint32_t numIndices;
-					bx::read(reader, numIndices);
+					bx::read(reader, numIndices, &err);
 					const bgfx::Memory* mem = bgfx::alloc(numIndices*2);
-					bx::read(reader, mem->data, mem->size);
+					bx::read(reader, mem->data, mem->size, &err);
 					group.m_ibh = bgfx::createIndexBuffer(mem);
 				}
 				break;
@@ -686,31 +688,31 @@ struct Mesh
 			case BGFX_CHUNK_MAGIC_PRI:
 				{
 					uint16_t len;
-					bx::read(reader, len);
+					bx::read(reader, len, &err);
 
 					std::string material;
 					material.resize(len);
-					bx::read(reader, const_cast<char*>(material.c_str() ), len);
+					bx::read(reader, const_cast<char*>(material.c_str() ), len, &err);
 
 					uint16_t num;
-					bx::read(reader, num);
+					bx::read(reader, num, &err);
 
 					for (uint32_t ii = 0; ii < num; ++ii)
 					{
-						bx::read(reader, len);
+						bx::read(reader, len, &err);
 
 						std::string name;
 						name.resize(len);
-						bx::read(reader, const_cast<char*>(name.c_str() ), len);
+						bx::read(reader, const_cast<char*>(name.c_str() ), len, &err);
 
 						Primitive prim;
-						bx::read(reader, prim.m_startIndex);
-						bx::read(reader, prim.m_numIndices);
-						bx::read(reader, prim.m_startVertex);
-						bx::read(reader, prim.m_numVertices);
-						bx::read(reader, prim.m_sphere);
-						bx::read(reader, prim.m_aabb);
-						bx::read(reader, prim.m_obb);
+						bx::read(reader, prim.m_startIndex, &err);
+						bx::read(reader, prim.m_numIndices, &err);
+						bx::read(reader, prim.m_startVertex, &err);
+						bx::read(reader, prim.m_numVertices, &err);
+						bx::read(reader, prim.m_sphere, &err);
+						bx::read(reader, prim.m_aabb, &err);
+						bx::read(reader, prim.m_obb, &err);
 
 						group.m_prims.push_back(prim);
 					}

examples/14-shadowvolumes/shadowvolumes.cpp

@@ -1067,7 +1067,6 @@ struct Model
 			::setRenderState(_renderState);
 
 			// Submit
-			BX_ASSERT(bgfx::kInvalidHandle != m_program, "Error, program is not set.");
 			::submit(_viewId, m_program);
 		}
 	}

examples/16-shadowmaps/shadowmaps.cpp

@@ -2326,7 +2326,7 @@ public:
 
 				// Compute split distances.
 				const uint8_t maxNumSplits = 4;
-				BX_ASSERT(maxNumSplits >= settings.m_numSplits, "Error! Max num splits.");
+				BX_ASSERT(maxNumSplits >= m_settings.m_numSplits, "Error! Max num splits.");
 
 				float splitSlices[maxNumSplits*2];
 				splitFrustum(splitSlices

examples/42-bunnylod/bunnylod.cpp

@@ -188,21 +188,25 @@ public:
 		m_cachePermutation = NULL;
 		m_originalVertices = 0;
 
+		bx::Error err;
+
 		bx::FileReader reader;
 
 		if (bx::open(&reader, kCacheFilePath) )
 		{
-			bx::read(&reader, m_originalVertices);
-			bx::read(&reader, m_totalVertices);
+			bx::read(&reader, m_originalVertices, &err);
+			bx::read(&reader, m_totalVertices, &err);
 			m_cacheWeld = (uint32_t*)BX_ALLOC(entry::getAllocator(), m_originalVertices * sizeof(uint32_t) );
 
-			bx::read(&reader, m_cacheWeld, m_originalVertices * sizeof(uint32_t) );
+			bx::read(&reader, m_cacheWeld, m_originalVertices * sizeof(uint32_t), &err);
 			m_cachePermutation = (uint32_t*)BX_ALLOC(entry::getAllocator(), m_totalVertices * sizeof(uint32_t) );
 
-			bx::read(&reader, m_cachePermutation, m_totalVertices * sizeof(uint32_t) );
+			bx::read(&reader, m_cachePermutation, m_totalVertices * sizeof(uint32_t), &err);
 			m_map = (uint32_t*)BX_ALLOC(entry::getAllocator(), m_totalVertices * sizeof(uint32_t) );
 
-			if (bx::read(&reader, m_map, m_totalVertices * sizeof(uint32_t) ) != int32_t(m_totalVertices * sizeof(uint32_t) ) )
+			bx::read(&reader, m_map, m_totalVertices * sizeof(uint32_t), &err);
+
+			if (!err.isOk() )
 			{
 				// read fail
 				BX_FREE(entry::getAllocator(), m_cacheWeld);
@@ -225,11 +229,14 @@ public:
 
 		if (bx::open(&writer, kCacheFilePath) )
 		{
-			bx::write(&writer, m_originalVertices);
-			bx::write(&writer, m_totalVertices);
-			bx::write(&writer, m_cacheWeld, m_originalVertices * sizeof(uint32_t) );
-			bx::write(&writer, m_cachePermutation, m_totalVertices * sizeof(uint32_t) );
-			bx::write(&writer, m_map, m_totalVertices * sizeof(uint32_t) );
+			bx::Error err;
+
+			bx::write(&writer, m_originalVertices, &err);
+			bx::write(&writer, m_totalVertices, &err);
+			bx::write(&writer, m_cacheWeld, m_originalVertices * sizeof(uint32_t), &err);
+			bx::write(&writer, m_cachePermutation, m_totalVertices * sizeof(uint32_t), &err);
+			bx::write(&writer, m_map, m_totalVertices * sizeof(uint32_t), &err);
+
 			bx::close(&writer);
 		}
 	}

examples/45-bokeh/bokeh.cpp

@@ -904,9 +904,9 @@ public:
 		{
 			bgfx::destroy(m_bokehTexture);
 		}
-		BX_ASSERT(0 < _lobeCount);
+		BX_ASSERT(0 < _lobeCount, "");
 
-		const uint32_t bokehSize = 128;
+		const int32_t bokehSize = 128;
 
 		const bgfx::Memory* mem = bgfx::alloc(bokehSize*bokehSize*4);
 		bx::memSet(mem->data, 0x00, bokehSize*bokehSize*4);
@@ -926,8 +926,7 @@ public:
 
 			// apply shape to circular distribution
 			const float shapeScale = bokehShapeFromAngle(_lobeCount, _lobeRadiusMin, radiusDelta2x, _lobeRotation, theta);
-			BX_ASSERT(_lobeRadiusMin <= shapeScale);
-			BX_ASSERT(shapeScale <= _maxRadius);
+			BX_ASSERT(_lobeRadiusMin <= shapeScale, "");
 
 			float spiralCoordX = bx::cos(theta) * (radius * shapeScale);
 			float spiralCoordY = bx::sin(theta) * (radius * shapeScale);
@@ -941,10 +940,10 @@ public:
 			int32_t pixelCoordX = int32_t(bx::floor(spiralCoordX * float(bokehSize-1) + 0.5f));
 			int32_t pixelCoordY = int32_t(bx::floor(spiralCoordY * float(bokehSize-1) + 0.5f));
 
-			BX_ASSERT(0 <= pixelCoordX);
-			BX_ASSERT(0 <= pixelCoordY);
-			BX_ASSERT(pixelCoordX < bokehSize);
-			BX_ASSERT(pixelCoordY < bokehSize);
+			BX_ASSERT(0 <= pixelCoordX, "");
+			BX_ASSERT(0 <= pixelCoordY, "");
+			BX_ASSERT(pixelCoordX < bokehSize, "");
+			BX_ASSERT(pixelCoordY < bokehSize, "");
 
 			// plot sample position, track for total samples
 			uint32_t offset = (pixelCoordY * bokehSize + pixelCoordX) * 4;

examples/common/aviwriter.h

@@ -41,93 +41,95 @@ struct AviWriter
 		// is 0, 0. DIB expect OpenGL style coordinates, so this is inverted logic for AVI writer.
 		m_yflip = !_yflip;
 
+		bx::Error err;
+
 		bx::StaticMemoryBlockWriter mem(m_frame, 8);
 		// Stream Data (LIST 'movi' Chunk) http://msdn.microsoft.com/en-us/library/ms899496.aspx
-		bx::write(&mem, BX_MAKEFOURCC('0', '0', 'd', 'b') );
-		bx::write(&mem, m_frameSize);
+		bx::write(&mem, BX_MAKEFOURCC('0', '0', 'd', 'b'), &err);
+		bx::write(&mem, m_frameSize, &err);
 
-		bx::write(m_writer, BX_MAKEFOURCC('R', 'I', 'F', 'F') );
+		bx::write(m_writer, BX_MAKEFOURCC('R', 'I', 'F', 'F'), &err);
 		m_riffSizeOffset = m_writer->seek();
-		bx::write(m_writer, UINT32_C(0) );
+		bx::write(m_writer, uint32_t(0), &err);
 
-		bx::write(m_writer, BX_MAKEFOURCC('A', 'V', 'I', ' ') );
+		bx::write(m_writer, BX_MAKEFOURCC('A', 'V', 'I', ' '), &err);
 
 		// AVI RIFF Form http://msdn.microsoft.com/en-us/library/ms899422.aspx
-		bx::write(m_writer, BX_MAKEFOURCC('L', 'I', 'S', 'T') );
-		bx::write(m_writer, UINT32_C(192) );
-		bx::write(m_writer, BX_MAKEFOURCC('h', 'd', 'r', 'l') );
+		bx::write(m_writer, BX_MAKEFOURCC('L', 'I', 'S', 'T'), &err);
+		bx::write(m_writer, uint32_t(192), &err);
+		bx::write(m_writer, BX_MAKEFOURCC('h', 'd', 'r', 'l'), &err);
 
 		// AVI Main Header http://msdn.microsoft.com/en-us/library/ms779632.aspx
-		bx::write(m_writer, BX_MAKEFOURCC('a', 'v', 'i', 'h') );
-		bx::write(m_writer, UINT32_C(56) );
-		bx::write(m_writer, UINT32_C(0) );      // dwMicroSecPerFrame
-		bx::write(m_writer, UINT32_C(0) );      // dwMaxBytesPerSec
-		bx::write(m_writer, UINT32_C(0) );      // dwPaddingGranularity
-		bx::write(m_writer, UINT32_C(0x110) );  // dwFlags
+		bx::write(m_writer, BX_MAKEFOURCC('a', 'v', 'i', 'h'), &err);
+		bx::write(m_writer, uint32_t(56), &err);
+		bx::write(m_writer, uint32_t(0), &err);      // dwMicroSecPerFrame
+		bx::write(m_writer, uint32_t(0), &err);      // dwMaxBytesPerSec
+		bx::write(m_writer, uint32_t(0), &err);      // dwPaddingGranularity
+		bx::write(m_writer, uint32_t(0x110), &err);  // dwFlags
 
 		m_totalFramesOffset = m_writer->seek();
-		bx::write(m_writer, UINT32_C(0) );      // dwTotalFrames
-
-		bx::write(m_writer, UINT32_C(0) );      // dwInitialFrames
-		bx::write(m_writer, UINT32_C(1) );      // dwStreams
-		bx::write(m_writer, UINT32_C(0) );      // dwSuggestedBufferSize
-		bx::write(m_writer, _width);            // dwWidth
-		bx::write(m_writer, _height);           // dwHeight
-		bx::write(m_writer, UINT32_C(0) );      // dwReserved0
-		bx::write(m_writer, UINT32_C(0) );      // dwReserved1
-		bx::write(m_writer, UINT32_C(0) );      // dwReserved2
-		bx::write(m_writer, UINT32_C(0) );      // dwReserved3
-
-		bx::write(m_writer, BX_MAKEFOURCC('L', 'I', 'S', 'T') );
-		bx::write(m_writer, UINT32_C(116) );
-		bx::write(m_writer, BX_MAKEFOURCC('s', 't', 'r', 'l') );
+		bx::write(m_writer, uint32_t(0), &err);      // dwTotalFrames
+
+		bx::write(m_writer, uint32_t(0), &err);      // dwInitialFrames
+		bx::write(m_writer, uint32_t(1), &err);      // dwStreams
+		bx::write(m_writer, uint32_t(0), &err);      // dwSuggestedBufferSize
+		bx::write(m_writer, _width, &err);           // dwWidth
+		bx::write(m_writer, _height, &err);          // dwHeight
+		bx::write(m_writer, uint32_t(0), &err);      // dwReserved0
+		bx::write(m_writer, uint32_t(0), &err);      // dwReserved1
+		bx::write(m_writer, uint32_t(0), &err);      // dwReserved2
+		bx::write(m_writer, uint32_t(0), &err);      // dwReserved3
+
+		bx::write(m_writer, BX_MAKEFOURCC('L', 'I', 'S', 'T'), &err);
+		bx::write(m_writer, uint32_t(116), &err);
+		bx::write(m_writer, BX_MAKEFOURCC('s', 't', 'r', 'l'), &err);
 
 		// AVISTREAMHEADER Structure http://msdn.microsoft.com/en-us/library/ms779638.aspx
-		bx::write(m_writer, BX_MAKEFOURCC('s', 't', 'r', 'h') );
-		bx::write(m_writer, UINT32_C(56) );
+		bx::write(m_writer, BX_MAKEFOURCC('s', 't', 'r', 'h'), &err);
+		bx::write(m_writer, uint32_t(56), &err);
 		// AVI Stream Headers http://msdn.microsoft.com/en-us/library/ms899423.aspx
-		bx::write(m_writer, BX_MAKEFOURCC('v', 'i', 'd', 's') ); // fccType
-		bx::write(m_writer, BX_MAKEFOURCC('D', 'I', 'B', ' ') ); // fccHandler
-		bx::write(m_writer, UINT32_C(0) );      // dwFlags
-		bx::write(m_writer, uint16_t(0) );      // wPriority
-		bx::write(m_writer, uint16_t(0) );      // wLanguage
-		bx::write(m_writer, UINT32_C(0) );      // dwInitialFrames
-		bx::write(m_writer, UINT32_C(1) );      // dwScale
-		bx::write(m_writer, _fps);              // dwRate
-		bx::write(m_writer, UINT32_C(0) );      // dwStart
+		bx::write(m_writer, BX_MAKEFOURCC('v', 'i', 'd', 's'), &err); // fccType
+		bx::write(m_writer, BX_MAKEFOURCC('D', 'I', 'B', ' '), &err); // fccHandler
+		bx::write(m_writer, uint32_t(0), &err);      // dwFlags
+		bx::write(m_writer, uint16_t(0), &err);      // wPriority
+		bx::write(m_writer, uint16_t(0), &err);      // wLanguage
+		bx::write(m_writer, uint32_t(0), &err);      // dwInitialFrames
+		bx::write(m_writer, uint32_t(1), &err);      // dwScale
+		bx::write(m_writer, _fps, &err);             // dwRate
+		bx::write(m_writer, uint32_t(0), &err);      // dwStart
 
 		m_lengthOffset = m_writer->seek();
-		bx::write(m_writer, UINT32_C(0) );      // dwLength
+		bx::write(m_writer, uint32_t(0), &err);      // dwLength
 
-		bx::write(m_writer, m_frameSize);       // dwSuggestedBufferSize
-		bx::write(m_writer, UINT32_MAX);        // dwQuality
-		bx::write(m_writer, UINT32_C(0) );      // dwSampleSize
-		bx::write(m_writer, int16_t(0) );       // rcFrame.left
-		bx::write(m_writer, int16_t(0) );       // rcFrame.top
-		bx::write(m_writer, uint16_t(_width) ); // rcFrame.right
-		bx::write(m_writer, uint16_t(_height) );// rcFrame.bottom
+		bx::write(m_writer, m_frameSize, &err);      // dwSuggestedBufferSize
+		bx::write(m_writer, UINT32_MAX, &err);       // dwQuality
+		bx::write(m_writer, uint32_t(0), &err);      // dwSampleSize
+		bx::write(m_writer, int16_t(0), &err);       // rcFrame.left
+		bx::write(m_writer, int16_t(0), &err);       // rcFrame.top
+		bx::write(m_writer, uint16_t(_width), &err); // rcFrame.right
+		bx::write(m_writer, uint16_t(_height), &err);// rcFrame.bottom
 
-		bx::write(m_writer, BX_MAKEFOURCC('s', 't', 'r', 'f') );
-		bx::write(m_writer, UINT32_C(40) );
+		bx::write(m_writer, BX_MAKEFOURCC('s', 't', 'r', 'f'), &err);
+		bx::write(m_writer, uint32_t(40), &err);
 
 		// BITMAPINFOHEADER structure http://msdn.microsoft.com/en-us/library/windows/desktop/dd318229%28v=vs.85%29.aspx
-		bx::write(m_writer, UINT32_C(40) );     // biSize
-		bx::write(m_writer, _width);            // biWidth
-		bx::write(m_writer, _height);           // biHeight
-		bx::write(m_writer, uint16_t(1) );      // biPlanes
-		bx::write(m_writer, uint16_t(24) );     // biBitCount
-		bx::write(m_writer, UINT32_C(0) );      // biCompression
-		bx::write(m_writer, m_frameSize);       // biSizeImage
-		bx::write(m_writer, UINT32_C(0) );      // biXPelsPerMeter
-		bx::write(m_writer, UINT32_C(0) );      // biYPelsPerMeter
-		bx::write(m_writer, UINT32_C(0) );      // biClrUsed
-		bx::write(m_writer, UINT32_C(0) );      // biClrImportant
-
-		bx::write(m_writer, BX_MAKEFOURCC('L', 'I', 'S', 'T') );
+		bx::write(m_writer, uint32_t(40), &err);     // biSize
+		bx::write(m_writer, _width, &err);           // biWidth
+		bx::write(m_writer, _height, &err);          // biHeight
+		bx::write(m_writer, uint16_t(1), &err);      // biPlanes
+		bx::write(m_writer, uint16_t(24), &err);     // biBitCount
+		bx::write(m_writer, uint32_t(0), &err);      // biCompression
+		bx::write(m_writer, m_frameSize, &err);      // biSizeImage
+		bx::write(m_writer, uint32_t(0), &err);      // biXPelsPerMeter
+		bx::write(m_writer, uint32_t(0), &err);      // biYPelsPerMeter
+		bx::write(m_writer, uint32_t(0), &err);      // biClrUsed
+		bx::write(m_writer, uint32_t(0), &err);      // biClrImportant
+
+		bx::write(m_writer, BX_MAKEFOURCC('L', 'I', 'S', 'T'), &err);
 
 		m_moviListOffset = m_writer->seek();
-		bx::write(m_writer, UINT32_C(0) );
-		bx::write(m_writer, BX_MAKEFOURCC('m', 'o', 'v', 'i') );
+		bx::write(m_writer, uint32_t(0), &err);
+		bx::write(m_writer, BX_MAKEFOURCC('m', 'o', 'v', 'i'), &err);
 
 		return true;
 	}
@@ -136,32 +138,34 @@ struct AviWriter
 	{
 		if (NULL != m_frame)
 		{
+			bx::Error err;
+
 			int64_t pos = m_writer->seek();
 			m_writer->seek(m_moviListOffset, bx::Whence::Begin);
-			bx::write(m_writer, uint32_t(pos-m_moviListOffset-4) );
+			bx::write(m_writer, uint32_t(pos-m_moviListOffset-4), &err);
 			m_writer->seek(pos, bx::Whence::Begin);
 
-			bx::write(m_writer, BX_MAKEFOURCC('i', 'd', 'x', '1') );
-			bx::write(m_writer, m_numFrames*16);
+			bx::write(m_writer, BX_MAKEFOURCC('i', 'd', 'x', '1'), &err);
+			bx::write(m_writer, m_numFrames*16, &err);
 
 			for (uint32_t ii = 0, offset = 4; ii < m_numFrames; ++ii)
 			{
-				bx::write(m_writer, BX_MAKEFOURCC('0', '0', 'd', 'b') );
-				bx::write(m_writer, UINT32_C(16) );
-				bx::write(m_writer, offset);
-				bx::write(m_writer, m_frameSize);
+				bx::write(m_writer, BX_MAKEFOURCC('0', '0', 'd', 'b'), &err);
+				bx::write(m_writer, uint32_t(16), &err);
+				bx::write(m_writer, offset, &err);
+				bx::write(m_writer, m_frameSize, &err);
 				offset += m_frameSize + 8;
 			}
 
 			pos = m_writer->seek();
 			m_writer->seek(m_riffSizeOffset, bx::Whence::Begin);
-			bx::write(m_writer, uint32_t(pos-m_riffSizeOffset-4) );
+			bx::write(m_writer, uint32_t(pos-m_riffSizeOffset-4), &err);
 
 			m_writer->seek(m_totalFramesOffset, bx::Whence::Begin);
-			bx::write(m_writer, m_numFrames);
+			bx::write(m_writer, m_numFrames, &err);
 
 			m_writer->seek(m_lengthOffset, bx::Whence::Begin);
-			bx::write(m_writer, m_numFrames);
+			bx::write(m_writer, m_numFrames, &err);
 
 			bx::close(m_writer);
 
@@ -210,7 +214,8 @@ struct AviWriter
 				}
 			}
 
-			bx::write(m_writer, m_frame, m_frameSize+8);
+			bx::Error err;
+			bx::write(m_writer, m_frame, m_frameSize+8, &err);
 		}
 	}
 

examples/common/bgfx_utils.cpp

@@ -29,7 +29,7 @@ void* load(bx::FileReaderI* _reader, bx::AllocatorI* _allocator, const char* _fi
 	{
 		uint32_t size = (uint32_t)bx::getSize(_reader);
 		void* data = BX_ALLOC(_allocator, size);
-		bx::read(_reader, data, size);
+		bx::read(_reader, data, size, bx::ErrorAssert{});
 		bx::close(_reader);
 		if (NULL != _size)
 		{
@@ -66,7 +66,7 @@ static const bgfx::Memory* loadMem(bx::FileReaderI* _reader, const char* _filePa
 	{
 		uint32_t size = (uint32_t)bx::getSize(_reader);
 		const bgfx::Memory* mem = bgfx::alloc(size+1);
-		bx::read(_reader, mem->data, size);
+		bx::read(_reader, mem->data, size, bx::ErrorAssert{});
 		bx::close(_reader);
 		mem->data[mem->size-1] = '\0';
 		return mem;
@@ -82,7 +82,7 @@ static void* loadMem(bx::FileReaderI* _reader, bx::AllocatorI* _allocator, const
 	{
 		uint32_t size = (uint32_t)bx::getSize(_reader);
 		void* data = BX_ALLOC(_allocator, size);
-		bx::read(_reader, data, size);
+		bx::read(_reader, data, size, bx::ErrorAssert{});
 		bx::close(_reader);
 
 		if (NULL != _size)
@@ -375,7 +375,7 @@ void Group::reset()
 
 namespace bgfx
 {
-	int32_t read(bx::ReaderI* _reader, bgfx::VertexLayout& _layout, bx::Error* _err = NULL);
+	int32_t read(bx::ReaderI* _reader, bgfx::VertexLayout& _layout, bx::Error* _err);
 }
 
 void Mesh::load(bx::ReaderSeekerI* _reader, bool _ramcopy)
@@ -402,17 +402,17 @@ void Mesh::load(bx::ReaderSeekerI* _reader, bool _ramcopy)
 		{
 			case kChunkVertexBuffer:
 			{
-				read(_reader, group.m_sphere);
-				read(_reader, group.m_aabb);
-				read(_reader, group.m_obb);
+				read(_reader, group.m_sphere, &err);
+				read(_reader, group.m_aabb, &err);
+				read(_reader, group.m_obb, &err);
 
-				read(_reader, m_layout);
+				read(_reader, m_layout, &err);
 
 				uint16_t stride = m_layout.getStride();
 
-				read(_reader, group.m_numVertices);
+				read(_reader, group.m_numVertices, &err);
 				const bgfx::Memory* mem = bgfx::alloc(group.m_numVertices*stride);
-				read(_reader, mem->data, mem->size);
+				read(_reader, mem->data, mem->size, &err);
 
 				if (_ramcopy)
 				{
@@ -426,23 +426,23 @@ void Mesh::load(bx::ReaderSeekerI* _reader, bool _ramcopy)
 
 			case kChunkVertexBufferCompressed:
 			{
-				read(_reader, group.m_sphere);
-				read(_reader, group.m_aabb);
-				read(_reader, group.m_obb);
+				read(_reader, group.m_sphere, &err);
+				read(_reader, group.m_aabb, &err);
+				read(_reader, group.m_obb, &err);
 
-				read(_reader, m_layout);
+				read(_reader, m_layout, &err);
 
 				uint16_t stride = m_layout.getStride();
 
-				read(_reader, group.m_numVertices);
+				read(_reader, group.m_numVertices, &err);
 
 				const bgfx::Memory* mem = bgfx::alloc(group.m_numVertices*stride);
 
 				uint32_t compressedSize;
-				bx::read(_reader, compressedSize);
+				bx::read(_reader, compressedSize, &err);
 
 				void* compressedVertices = BX_ALLOC(allocator, compressedSize);
-				bx::read(_reader, compressedVertices, compressedSize);
+				bx::read(_reader, compressedVertices, compressedSize, &err);
 
 				meshopt_decodeVertexBuffer(mem->data, group.m_numVertices, stride, (uint8_t*)compressedVertices, compressedSize);
 
@@ -460,9 +460,10 @@ void Mesh::load(bx::ReaderSeekerI* _reader, bool _ramcopy)
 
 			case kChunkIndexBuffer:
 			{
-				read(_reader, group.m_numIndices);
+				read(_reader, group.m_numIndices, &err);
+
 				const bgfx::Memory* mem = bgfx::alloc(group.m_numIndices*2);
-				read(_reader, mem->data, mem->size);
+				read(_reader, mem->data, mem->size, &err);
 
 				if (_ramcopy)
 				{
@@ -476,16 +477,16 @@ void Mesh::load(bx::ReaderSeekerI* _reader, bool _ramcopy)
 
 			case kChunkIndexBufferCompressed:
 			{
-				bx::read(_reader, group.m_numIndices);
+				bx::read(_reader, group.m_numIndices, &err);
 
 				const bgfx::Memory* mem = bgfx::alloc(group.m_numIndices*2);
 
 				uint32_t compressedSize;
-				bx::read(_reader, compressedSize);
+				bx::read(_reader, compressedSize, &err);
 
 				void* compressedIndices = BX_ALLOC(allocator, compressedSize);
 
-				bx::read(_reader, compressedIndices, compressedSize);
+				bx::read(_reader, compressedIndices, compressedSize, &err);
 
 				meshopt_decodeIndexBuffer(mem->data, group.m_numIndices, 2, (uint8_t*)compressedIndices, compressedSize);
 
@@ -504,31 +505,31 @@ void Mesh::load(bx::ReaderSeekerI* _reader, bool _ramcopy)
 			case kChunkPrimitive:
 			{
 				uint16_t len;
-				read(_reader, len);
+				read(_reader, len, &err);
 
 				stl::string material;
 				material.resize(len);
-				read(_reader, const_cast<char*>(material.c_str() ), len);
+				read(_reader, const_cast<char*>(material.c_str() ), len, &err);
 
 				uint16_t num;
-				read(_reader, num);
+				read(_reader, num, &err);
 
 				for (uint32_t ii = 0; ii < num; ++ii)
 				{
-					read(_reader, len);
+					read(_reader, len, &err);
 
 					stl::string name;
 					name.resize(len);
-					read(_reader, const_cast<char*>(name.c_str() ), len);
+					read(_reader, const_cast<char*>(name.c_str() ), len, &err);
 
 					Primitive prim;
-					read(_reader, prim.m_startIndex);
-					read(_reader, prim.m_numIndices);
-					read(_reader, prim.m_startVertex);
-					read(_reader, prim.m_numVertices);
-					read(_reader, prim.m_sphere);
-					read(_reader, prim.m_aabb);
-					read(_reader, prim.m_obb);
+					read(_reader, prim.m_startIndex, &err);
+					read(_reader, prim.m_numIndices, &err);
+					read(_reader, prim.m_startVertex, &err);
+					read(_reader, prim.m_numVertices, &err);
+					read(_reader, prim.m_sphere, &err);
+					read(_reader, prim.m_aabb, &err);
+					read(_reader, prim.m_obb, &err);
 
 					group.m_prims.push_back(prim);
 				}

examples/common/debugdraw/debugdraw.cpp

@@ -9,6 +9,7 @@
 #include "../bgfx_utils.h"
 #include "../packrect.h"
 
+#include <bx/debug.h>
 #include <bx/mutex.h>
 #include <bx/math.h>
 #include <bx/sort.h>
@@ -1026,6 +1027,7 @@ struct DebugDrawEncoderImpl
 	void init(bgfx::Encoder* _encoder)
 	{
 		m_defaultEncoder = _encoder;
+		m_state = State::Count;
 	}
 
 	void shutdown()
@@ -1034,7 +1036,7 @@ struct DebugDrawEncoderImpl
 
 	void begin(bgfx::ViewId _viewId, bool _depthTestLess, bgfx::Encoder* _encoder)
 	{
-		BX_ASSERT(State::Count == m_state);
+		BX_ASSERT(State::Count == m_state, "");
 
 		m_viewId        = _viewId;
 		m_encoder       = _encoder == NULL ? m_defaultEncoder : _encoder;
@@ -1079,14 +1081,14 @@ struct DebugDrawEncoderImpl
 
 	void push()
 	{
-		BX_ASSERT(State::Count != m_state);
+		BX_ASSERT(State::Count != m_state, "");
 		++m_stack;
 		m_attrib[m_stack] = m_attrib[m_stack-1];
 	}
 
 	void pop()
 	{
-		BX_ASSERT(State::Count != m_state);
+		BX_ASSERT(State::Count != m_state, "");
 		const Attrib& curr = m_attrib[m_stack];
 		const Attrib& prev = m_attrib[m_stack-1];
 		if (curr.m_stipple != prev.m_stipple
@@ -1099,7 +1101,7 @@ struct DebugDrawEncoderImpl
 
 	void setDepthTestLess(bool _depthTestLess)
 	{
-		BX_ASSERT(State::Count != m_state);
+		BX_ASSERT(State::Count != m_state, "");
 		if (m_depthTestLess != _depthTestLess)
 		{
 			m_depthTestLess = _depthTestLess;
@@ -1115,7 +1117,7 @@ struct DebugDrawEncoderImpl
 
 	void setTransform(const void* _mtx, uint16_t _num = 1, bool _flush = true)
 	{
-		BX_ASSERT(State::Count != m_state);
+		BX_ASSERT(State::Count != m_state, "");
 		if (_flush)
 		{
 			flush();
@@ -1151,7 +1153,7 @@ struct DebugDrawEncoderImpl
 	void pushTransform(const void* _mtx, uint16_t _num, bool _flush = true)
 	{
 		BX_ASSERT(m_mtxStackCurrent < BX_COUNTOF(m_mtxStack), "Out of matrix stack!");
-		BX_ASSERT(State::Count != m_state);
+		BX_ASSERT(State::Count != m_state, "");
 		if (_flush)
 		{
 			flush();
@@ -1181,7 +1183,7 @@ struct DebugDrawEncoderImpl
 
 	void popTransform(bool _flush = true)
 	{
-		BX_ASSERT(State::Count != m_state);
+		BX_ASSERT(State::Count != m_state, "");
 		if (_flush)
 		{
 			flush();
@@ -1241,25 +1243,25 @@ struct DebugDrawEncoderImpl
 
 	void setColor(uint32_t _abgr)
 	{
-		BX_ASSERT(State::Count != m_state);
+		BX_ASSERT(State::Count != m_state, "");
 		m_attrib[m_stack].m_abgr = _abgr;
 	}
 
 	void setLod(uint8_t _lod)
 	{
-		BX_ASSERT(State::Count != m_state);
+		BX_ASSERT(State::Count != m_state, "");
 		m_attrib[m_stack].m_lod = _lod;
 	}
 
 	void setWireframe(bool _wireframe)
 	{
-		BX_ASSERT(State::Count != m_state);
+		BX_ASSERT(State::Count != m_state, "");
 		m_attrib[m_stack].m_wireframe = _wireframe;
 	}
 
 	void setStipple(bool _stipple, float _scale = 1.0f, float _offset = 0.0f)
 	{
-		BX_ASSERT(State::Count != m_state);
+		BX_ASSERT(State::Count != m_state, "");
 
 		Attrib& attrib = m_attrib[m_stack];
 
@@ -1281,7 +1283,7 @@ struct DebugDrawEncoderImpl
 
 	void moveTo(float _x, float _y, float _z = 0.0f)
 	{
-		BX_ASSERT(State::Count != m_state);
+		BX_ASSERT(State::Count != m_state, "");
 
 		softFlush();
 
@@ -1301,7 +1303,7 @@ struct DebugDrawEncoderImpl
 
 	void moveTo(const bx::Vec3& _pos)
 	{
-		BX_ASSERT(State::Count != m_state);
+		BX_ASSERT(State::Count != m_state, "");
 		moveTo(_pos.x, _pos.y, _pos.z);
 	}
 
@@ -1312,7 +1314,7 @@ struct DebugDrawEncoderImpl
 
 	void lineTo(float _x, float _y, float _z = 0.0f)
 	{
-		BX_ASSERT(State::Count != m_state);
+		BX_ASSERT(State::Count != m_state, "");
 		if (State::None == m_state)
 		{
 			moveTo(_x, _y, _z);
@@ -1365,7 +1367,7 @@ struct DebugDrawEncoderImpl
 
 	void lineTo(const bx::Vec3& _pos)
 	{
-		BX_ASSERT(State::Count != m_state);
+		BX_ASSERT(State::Count != m_state, "");
 		lineTo(_pos.x, _pos.y, _pos.z);
 	}
 
@@ -1376,7 +1378,7 @@ struct DebugDrawEncoderImpl
 
 	void close()
 	{
-		BX_ASSERT(State::Count != m_state);
+		BX_ASSERT(State::Count != m_state, "");
 		DebugVertex& vertex = m_cache[m_vertexPos];
 		lineTo(vertex.m_x, vertex.m_y, vertex.m_z);
 

examples/common/entry/entry_sdl.cpp

@@ -536,7 +536,7 @@ namespace entry
 				bx::AllocatorI* allocator = getAllocator();
 				uint32_t size = (uint32_t)bx::getSize(reader);
 				void* data = BX_ALLOC(allocator, size + 1);
-				bx::read(reader, data, size);
+				bx::read(reader, data, size, bx::ErrorAssert{});
 				bx::close(reader);
 				((char*)data)[size] = '\0';
 

examples/common/font/font_manager.cpp

@@ -71,7 +71,6 @@ TrueTypeFont::~TrueTypeFont()
 
 bool TrueTypeFont::init(const uint8_t* _buffer, uint32_t _bufferSize, int32_t _fontIndex, uint32_t _pixelHeight, int16_t _widthPadding, int16_t _heightPadding)
 {
-	BX_ASSERT(m_font == NULL, "TrueTypeFont already initialized");
 	BX_ASSERT( (_bufferSize > 256 && _bufferSize < 100000000), "TrueType buffer size is suspicious");
 	BX_ASSERT( (_pixelHeight > 4 && _pixelHeight < 128), "TrueType buffer size is suspicious");
 	BX_UNUSED(_bufferSize);
@@ -89,8 +88,6 @@ bool TrueTypeFont::init(const uint8_t* _buffer, uint32_t _bufferSize, int32_t _f
 
 FontInfo TrueTypeFont::getFontInfo()
 {
-	BX_ASSERT(m_font != NULL, "TrueTypeFont not initialized");
-
 	int ascent;
 	int descent;
 	int lineGap;
@@ -115,8 +112,6 @@ FontInfo TrueTypeFont::getFontInfo()
 
 bool TrueTypeFont::bakeGlyphAlpha(CodePoint _codePoint, GlyphInfo& _glyphInfo, uint8_t* _outBuffer)
 {
-	BX_ASSERT(m_font != NULL, "TrueTypeFont not initialized");
-
 	int32_t ascent, descent, lineGap;
 	stbtt_GetFontVMetrics(&m_font, &ascent, &descent, &lineGap);
 
@@ -147,8 +142,6 @@ bool TrueTypeFont::bakeGlyphAlpha(CodePoint _codePoint, GlyphInfo& _glyphInfo, u
 
 bool TrueTypeFont::bakeGlyphDistance(CodePoint _codePoint, GlyphInfo& _glyphInfo, uint8_t* _outBuffer)
 {
-	BX_ASSERT(m_font != NULL, "TrueTypeFont not initialized");
-
 	int32_t ascent, descent, lineGap;
 	stbtt_GetFontVMetrics(&m_font, &ascent, &descent, &lineGap);
 
@@ -290,7 +283,7 @@ TrueTypeHandle FontManager::createTtf(const uint8_t* _buffer, uint32_t _size)
 
 void FontManager::destroyTtf(TrueTypeHandle _handle)
 {
-	BX_ASSERT(bgfx::isValid(_handle), "Invalid handle used");
+	BX_ASSERT(isValid(_handle), "Invalid handle used");
 	delete m_cachedFiles[_handle.idx].buffer;
 	m_cachedFiles[_handle.idx].bufferSize = 0;
 	m_cachedFiles[_handle.idx].buffer = NULL;
@@ -300,7 +293,7 @@ void FontManager::destroyTtf(TrueTypeHandle _handle)
 FontHandle FontManager::createFontByPixelSize(TrueTypeHandle _ttfHandle, uint32_t _typefaceIndex, uint32_t _pixelSize, uint32_t _fontType,
 		uint16_t _glyphWidthPadding, uint16_t _glyphHeightPadding)
 {
-	BX_ASSERT(bgfx::isValid(_ttfHandle), "Invalid handle used");
+	BX_ASSERT(isValid(_ttfHandle), "Invalid handle used");
 
 	TrueTypeFont* ttf = new TrueTypeFont();
 	if (!ttf->init(m_cachedFiles[_ttfHandle.idx].buffer, m_cachedFiles[_ttfHandle.idx].bufferSize, _typefaceIndex, _pixelSize, _glyphWidthPadding, _glyphHeightPadding) )
@@ -327,7 +320,7 @@ FontHandle FontManager::createFontByPixelSize(TrueTypeHandle _ttfHandle, uint32_
 
 FontHandle FontManager::createScaledFontToPixelSize(FontHandle _baseFontHandle, uint32_t _pixelSize)
 {
-	BX_ASSERT(bgfx::isValid(_baseFontHandle), "Invalid handle used");
+	BX_ASSERT(isValid(_baseFontHandle), "Invalid handle used");
 	CachedFont& baseFont = m_cachedFonts[_baseFontHandle.idx];
 	FontInfo& fontInfo = baseFont.fontInfo;
 
@@ -356,7 +349,7 @@ FontHandle FontManager::createScaledFontToPixelSize(FontHandle _baseFontHandle,
 
 void FontManager::destroyFont(FontHandle _handle)
 {
-	BX_ASSERT(bgfx::isValid(_handle), "Invalid handle used");
+	BX_ASSERT(isValid(_handle), "Invalid handle used");
 
 	CachedFont& font = m_cachedFonts[_handle.idx];
 
@@ -372,7 +365,7 @@ void FontManager::destroyFont(FontHandle _handle)
 
 bool FontManager::preloadGlyph(FontHandle _handle, const wchar_t* _string)
 {
-	BX_ASSERT(bgfx::isValid(_handle), "Invalid handle used");
+	BX_ASSERT(isValid(_handle), "Invalid handle used");
 	CachedFont& font = m_cachedFonts[_handle.idx];
 
 	if (NULL == font.trueTypeFont)
@@ -394,7 +387,7 @@ bool FontManager::preloadGlyph(FontHandle _handle, const wchar_t* _string)
 
 bool FontManager::preloadGlyph(FontHandle _handle, CodePoint _codePoint)
 {
-	BX_ASSERT(bgfx::isValid(_handle), "Invalid handle used");
+	BX_ASSERT(isValid(_handle), "Invalid handle used");
 	CachedFont& font = m_cachedFonts[_handle.idx];
 	FontInfo& fontInfo = font.fontInfo;
 
@@ -472,7 +465,7 @@ bool FontManager::preloadGlyph(FontHandle _handle, CodePoint _codePoint)
 
 bool FontManager::addGlyphBitmap(FontHandle _handle, CodePoint _codePoint, uint16_t _width, uint16_t _height, uint16_t _pitch, float extraScale, const uint8_t* _bitmapBuffer, float glyphOffsetX, float glyphOffsetY)
 {
-	BX_ASSERT(bgfx::isValid(_handle), "Invalid handle used");
+	BX_ASSERT(isValid(_handle), "Invalid handle used");
 	CachedFont& font = m_cachedFonts[_handle.idx];
 
 	GlyphHashMap::iterator iter = font.cachedGlyphs.find(_codePoint);
@@ -519,7 +512,7 @@ bool FontManager::addGlyphBitmap(FontHandle _handle, CodePoint _codePoint, uint1
 
 const FontInfo& FontManager::getFontInfo(FontHandle _handle) const
 {
-	BX_ASSERT(bgfx::isValid(_handle), "Invalid handle used");
+	BX_ASSERT(isValid(_handle), "Invalid handle used");
 	return m_cachedFonts[_handle.idx].fontInfo;
 }
 

examples/common/font/text_buffer_manager.cpp

@@ -363,7 +363,7 @@ void TextBuffer::appendText(FontHandle _fontHandle, const char* _string, const c
 	{
 		_end = _string + bx::strLen(_string);
 	}
-	BX_ASSERT(_end >= _string);
+	BX_ASSERT(_end >= _string, "");
 
 	const FontInfo& font = m_fontManager->getFontInfo(_fontHandle);
 	if (font.fontType & FONT_TYPE_MASK_DISTANCE_DROP_SHADOW)
@@ -416,7 +416,7 @@ void TextBuffer::appendText(FontHandle _fontHandle, const wchar_t* _string, cons
 	{
 		_end = _string + wcslen(_string);
 	}
-	BX_ASSERT(_end >= _string);
+	BX_ASSERT(_end >= _string, "");
 
 	const FontInfo& font = m_fontManager->getFontInfo(_fontHandle);
 	if (font.fontType & FONT_TYPE_MASK_DISTANCE_DROP_SHADOW)
@@ -892,7 +892,10 @@ TextBufferManager::TextBufferManager(FontManager* _fontManager)
 
 TextBufferManager::~TextBufferManager()
 {
-	BX_ASSERT(m_textBufferHandles.getNumHandles() == 0, "All the text buffers must be destroyed before destroying the manager");
+	BX_ASSERT(
+		  m_textBufferHandles.getNumHandles() == 0
+		, "All the text buffers must be destroyed before destroying the manager"
+		);
 	delete [] m_textBuffers;
 
 	bgfx::destroy(u_params);
@@ -927,7 +930,7 @@ TextBufferHandle TextBufferManager::createTextBuffer(uint32_t _type, BufferType:
 
 void TextBufferManager::destroyTextBuffer(TextBufferHandle _handle)
 {
-	BX_ASSERT(bgfx::isValid(_handle), "Invalid handle used");
+	BX_ASSERT(isValid(_handle), "Invalid handle used");
 
 	BufferCache& bc = m_textBuffers[_handle.idx];
 	m_textBufferHandles.free(_handle.idx);
@@ -970,7 +973,7 @@ void TextBufferManager::destroyTextBuffer(TextBufferHandle _handle)
 
 void TextBufferManager::submitTextBuffer(TextBufferHandle _handle, bgfx::ViewId _id, int32_t _depth)
 {
-	BX_ASSERT(bgfx::isValid(_handle), "Invalid handle used");
+	BX_ASSERT(isValid(_handle), "Invalid handle used");
 
 	BufferCache& bc = m_textBuffers[_handle.idx];
 
@@ -1189,119 +1192,119 @@ void TextBufferManager::submitTextBuffer(TextBufferHandle _handle, bgfx::ViewId
 
 void TextBufferManager::setStyle(TextBufferHandle _handle, uint32_t _flags)
 {
-	BX_ASSERT(bgfx::isValid(_handle), "Invalid handle used");
+	BX_ASSERT(isValid(_handle), "Invalid handle used");
 	BufferCache& bc = m_textBuffers[_handle.idx];
 	bc.textBuffer->setStyle(_flags);
 }
 
 void TextBufferManager::setTextColor(TextBufferHandle _handle, uint32_t _rgba)
 {
-	BX_ASSERT(bgfx::isValid(_handle), "Invalid handle used");
+	BX_ASSERT(isValid(_handle), "Invalid handle used");
 	BufferCache& bc = m_textBuffers[_handle.idx];
 	bc.textBuffer->setTextColor(_rgba);
 }
 
 void TextBufferManager::setBackgroundColor(TextBufferHandle _handle, uint32_t _rgba)
 {
-	BX_ASSERT(bgfx::isValid(_handle), "Invalid handle used");
+	BX_ASSERT(isValid(_handle), "Invalid handle used");
 	BufferCache& bc = m_textBuffers[_handle.idx];
 	bc.textBuffer->setBackgroundColor(_rgba);
 }
 
 void TextBufferManager::setOverlineColor(TextBufferHandle _handle, uint32_t _rgba)
 {
-	BX_ASSERT(bgfx::isValid(_handle), "Invalid handle used");
+	BX_ASSERT(isValid(_handle), "Invalid handle used");
 	BufferCache& bc = m_textBuffers[_handle.idx];
 	bc.textBuffer->setOverlineColor(_rgba);
 }
 
 void TextBufferManager::setUnderlineColor(TextBufferHandle _handle, uint32_t _rgba)
 {
-	BX_ASSERT(bgfx::isValid(_handle), "Invalid handle used");
+	BX_ASSERT(isValid(_handle), "Invalid handle used");
 	BufferCache& bc = m_textBuffers[_handle.idx];
 	bc.textBuffer->setUnderlineColor(_rgba);
 }
 
 void TextBufferManager::setStrikeThroughColor(TextBufferHandle _handle, uint32_t _rgba)
 {
-	BX_ASSERT(bgfx::isValid(_handle), "Invalid handle used");
+	BX_ASSERT(isValid(_handle), "Invalid handle used");
 	BufferCache& bc = m_textBuffers[_handle.idx];
 	bc.textBuffer->setStrikeThroughColor(_rgba);
 }
 
 void TextBufferManager::setOutlineColor(TextBufferHandle _handle, uint32_t _rgba)
 {
-	BX_ASSERT(bgfx::isValid(_handle), "Invalid handle used");
+	BX_ASSERT(isValid(_handle), "Invalid handle used");
 	BufferCache& bc = m_textBuffers[_handle.idx];
 	bc.textBuffer->setOutlineColor(_rgba);
 }
 
 void TextBufferManager::setOutlineWidth(TextBufferHandle _handle, float _outlineWidth)
 {
-	BX_ASSERT(bgfx::isValid(_handle), "Invalid handle used");
+	BX_ASSERT(isValid(_handle), "Invalid handle used");
 	BufferCache& bc = m_textBuffers[_handle.idx];
 	bc.textBuffer->setOutlineWidth(_outlineWidth);
 }
 
 void TextBufferManager::setDropShadowColor(TextBufferHandle _handle, uint32_t _rgba)
 {
-	BX_ASSERT(bgfx::isValid(_handle), "Invalid handle used");
+	BX_ASSERT(isValid(_handle), "Invalid handle used");
 	BufferCache& bc = m_textBuffers[_handle.idx];
 	bc.textBuffer->setDropShadowColor(_rgba);
 }
 
 void TextBufferManager::setDropShadowOffset(TextBufferHandle _handle, float _u, float _v)
 {
-	BX_ASSERT(bgfx::isValid(_handle), "Invalid handle used");
+	BX_ASSERT(isValid(_handle), "Invalid handle used");
 	BufferCache& bc = m_textBuffers[_handle.idx];
 	bc.textBuffer->setDropShadowOffset(_u, _v);
 }
 
 void TextBufferManager::setDropShadowSoftener(TextBufferHandle _handle, float smoother)
 {
-	BX_ASSERT(bgfx::isValid(_handle), "Invalid handle used");
+	BX_ASSERT(isValid(_handle), "Invalid handle used");
 	BufferCache& bc = m_textBuffers[_handle.idx];
 	bc.textBuffer->setDropShadowSoftener(smoother);
 }
 
 void TextBufferManager::setPenPosition(TextBufferHandle _handle, float _x, float _y)
 {
-	BX_ASSERT(bgfx::isValid(_handle), "Invalid handle used");
+	BX_ASSERT(isValid(_handle), "Invalid handle used");
 	BufferCache& bc = m_textBuffers[_handle.idx];
 	bc.textBuffer->setPenPosition(_x, _y);
 }
 
 void TextBufferManager::appendText(TextBufferHandle _handle, FontHandle _fontHandle, const char* _string, const char* _end)
 {
-	BX_ASSERT(bgfx::isValid(_handle), "Invalid handle used");
+	BX_ASSERT(isValid(_handle), "Invalid handle used");
 	BufferCache& bc = m_textBuffers[_handle.idx];
 	bc.textBuffer->appendText(_fontHandle, _string, _end);
 }
 
 void TextBufferManager::appendText(TextBufferHandle _handle, FontHandle _fontHandle, const wchar_t* _string, const wchar_t* _end)
 {
-	BX_ASSERT(bgfx::isValid(_handle), "Invalid handle used");
+	BX_ASSERT(isValid(_handle), "Invalid handle used");
 	BufferCache& bc = m_textBuffers[_handle.idx];
 	bc.textBuffer->appendText(_fontHandle, _string, _end);
 }
 
 void TextBufferManager::appendAtlasFace(TextBufferHandle _handle, uint16_t _faceIndex)
 {
-	BX_ASSERT(bgfx::isValid(_handle), "Invalid handle used");
+	BX_ASSERT(isValid(_handle), "Invalid handle used");
 	BufferCache& bc = m_textBuffers[_handle.idx];
 	bc.textBuffer->appendAtlasFace(_faceIndex);
 }
 
 void TextBufferManager::clearTextBuffer(TextBufferHandle _handle)
 {
-	BX_ASSERT(bgfx::isValid(_handle), "Invalid handle used");
+	BX_ASSERT(isValid(_handle), "Invalid handle used");
 	BufferCache& bc = m_textBuffers[_handle.idx];
 	bc.textBuffer->clearTextBuffer();
 }
 
 TextRectangle TextBufferManager::getRectangle(TextBufferHandle _handle) const
 {
-	BX_ASSERT(bgfx::isValid(_handle), "Invalid handle used");
+	BX_ASSERT(isValid(_handle), "Invalid handle used");
 	BufferCache& bc = m_textBuffers[_handle.idx];
 	return bc.textBuffer->getRectangle();
 }

examples/common/ps/particle_system.cpp

@@ -626,7 +626,7 @@ namespace ps
 
 		void updateEmitter(EmitterHandle _handle, const EmitterUniforms* _uniforms)
 		{
-			BX_ASSERT(m_emitterAlloc.isValid(_handle.idx)
+			BX_ASSERT(isValid(_handle)
 				, "destroyEmitter handle %d is not valid."
 				, _handle.idx
 				);
@@ -645,7 +645,7 @@ namespace ps
 
 		void getAabb(EmitterHandle _handle, bx::Aabb& _outAabb)
 		{
-			BX_ASSERT(m_emitterAlloc.isValid(_handle.idx)
+			BX_ASSERT(isValid(_handle)
 				, "getAabb handle %d is not valid."
 				, _handle.idx
 				);
@@ -654,7 +654,7 @@ namespace ps
 
 		void destroyEmitter(EmitterHandle _handle)
 		{
-			BX_ASSERT(m_emitterAlloc.isValid(_handle.idx)
+			BX_ASSERT(isValid(_handle)
 				, "destroyEmitter handle %d is not valid."
 				, _handle.idx
 				);

scripts/bgfx.lua

@@ -46,7 +46,6 @@ function bgfxProjectBase(_kind, _defines)
 
 		links {
 			"bimg",
-			"bx",
 		}
 
 		configuration { "vs20* or mingw*" }
@@ -95,15 +94,12 @@ function bgfxProjectBase(_kind, _defines)
 
 	includedirs {
 		path.join(BGFX_DIR, "3rdparty"),
-		path.join(BX_DIR,   "include"),
 		path.join(BIMG_DIR, "include"),
 	}
 
 	defines (_defines)
 
-	links {
-		"bx",
-	}
+	using_bx()
 
 	if _OPTIONS["with-glfw"] then
 		defines {
@@ -111,11 +107,6 @@ function bgfxProjectBase(_kind, _defines)
 		}
 	end
 
-	configuration { "Debug" }
-		defines {
-			"BGFX_CONFIG_DEBUG=1",
-		}
-
 	configuration { "vs* or mingw*", "not durango" }
 		includedirs {
 			path.join(BGFX_DIR, "3rdparty/dxsdk/include"),

scripts/example-common.lua

@@ -7,7 +7,6 @@ project ("example-glue")
 	kind "StaticLib"
 
 	includedirs {
-		path.join(BX_DIR,   "include"),
 		path.join(BIMG_DIR, "include"),
 		path.join(BGFX_DIR, "include"),
 		path.join(BGFX_DIR, "3rdparty"),
@@ -17,11 +16,14 @@ project ("example-glue")
 		path.join(BGFX_DIR, "examples/common/example-glue.cpp"),
 	}
 
+	using_bx()
+
+	configuration {}
+
 project ("example-common")
 	kind "StaticLib"
 
 	includedirs {
-		path.join(BX_DIR,   "include"),
 		path.join(BIMG_DIR, "include"),
 		path.join(BGFX_DIR, "include"),
 		path.join(BGFX_DIR, "3rdparty"),
@@ -36,6 +38,8 @@ project ("example-common")
 		path.join(BGFX_DIR, "examples/common/**.h"),
 	}
 
+	using_bx()
+
 	if filesexist(BGFX_DIR, path.join(BGFX_DIR, "../bgfx-gnm"),
 		{ path.join(BGFX_DIR, "../bgfx-gnm/examples/common/entry/entry_orbis.cpp") }) then
 
@@ -90,3 +94,5 @@ project ("example-common")
 			"/ignore:4264" -- LNK4264: archiving object file compiled with /ZW into a static library; note that when authoring Windows Runtime types it is not recommended to link with a static library that contains Windows Runtime metadata
 		}
 		premake.vstudio.splashpath = "../../../examples/runtime/images/SplashScreen.png"
+
+	configuration {}

scripts/genie.lua

@@ -220,7 +220,6 @@ function exampleProjectDefaults()
 	debugdir (path.join(BGFX_DIR, "examples/runtime"))
 
 	includedirs {
-		path.join(BX_DIR,   "include"),
 		path.join(BIMG_DIR, "include"),
 		path.join(BGFX_DIR, "include"),
 		path.join(BGFX_DIR, "3rdparty"),
@@ -237,9 +236,10 @@ function exampleProjectDefaults()
 		"bgfx",
 		"bimg_decode",
 		"bimg",
-		"bx",
 	}
 
+	using_bx()
+
 	if _OPTIONS["with-webgpu"] then
 		usesWebGPU()
 	end
@@ -500,6 +500,10 @@ function exampleProject(_combined, ...)
 
 end
 
+dofile(path.join(BX_DIR,   "scripts/bx.lua"))
+dofile(path.join(BIMG_DIR, "scripts/bimg.lua"))
+dofile(path.join(BIMG_DIR, "scripts/bimg_decode.lua"))
+
 dofile "bgfx.lua"
 
 group "libs"
@@ -520,10 +524,6 @@ BGFX_CONFIG = userdefines()
 
 bgfxProject("", "StaticLib", BGFX_CONFIG)
 
-dofile(path.join(BX_DIR,   "scripts/bx.lua"))
-dofile(path.join(BIMG_DIR, "scripts/bimg.lua"))
-dofile(path.join(BIMG_DIR, "scripts/bimg_decode.lua"))
-
 if _OPTIONS["with-tools"] then
 	dofile(path.join(BIMG_DIR, "scripts/bimg_encode.lua"))
 end

scripts/geometryc.lua

@@ -23,9 +23,7 @@ project "geometryc"
 		path.join(BGFX_DIR, "examples/common/bounds.**"),
 	}
 
-	links {
-		"bx",
-	}
+	using_bx();
 
 	configuration { "mingw-*" }
 		targetextension ".exe"

scripts/geometryv.lua

@@ -5,7 +5,6 @@ project ("geometryv")
 	configuration {}
 
 	includedirs {
-		path.join(BX_DIR,   "include"),
 		path.join(BIMG_DIR, "include"),
 		path.join(BGFX_DIR, "include"),
 		path.join(BGFX_DIR, "3rdparty"),
@@ -23,9 +22,10 @@ project ("geometryv")
 		"bimg_decode",
 		"bimg",
 		"bgfx",
-		"bx",
 	}
 
+	using_bx()
+
 	if _OPTIONS["with-sdl"] then
 		defines { "ENTRY_CONFIG_USE_SDL=1" }
 		links   { "SDL2" }

scripts/shaderc.lua

@@ -601,7 +601,6 @@ project "shaderc"
 	kind "ConsoleApp"
 
 	includedirs {
-		path.join(BX_DIR,   "include"),
 		path.join(BIMG_DIR, "include"),
 		path.join(BGFX_DIR, "include"),
 
@@ -623,7 +622,6 @@ project "shaderc"
 	}
 
 	links {
-		"bx",
 		"fcpp",
 		"glslang",
 		"glsl-optimizer",
@@ -631,6 +629,8 @@ project "shaderc"
 		"spirv-cross",
 	}
 
+	using_bx()
+
 	files {
 		path.join(BGFX_DIR, "tools/shaderc/**.cpp"),
 		path.join(BGFX_DIR, "tools/shaderc/**.h"),

scripts/texturec.lua

@@ -8,7 +8,6 @@ project "texturec"
 	kind "ConsoleApp"
 
 	includedirs {
-		path.join(BX_DIR,   "include"),
 		path.join(BIMG_DIR, "include"),
 		path.join(BGFX_DIR, "include"),
 		path.join(BIMG_DIR, "3rdparty/iqa/include"),
@@ -22,9 +21,10 @@ project "texturec"
 		"bimg_decode",
 		"bimg_encode",
 		"bimg",
-		"bx",
 	}
 
+	using_bx()
+
 	configuration { "mingw-*" }
 		targetextension ".exe"
 		links {

scripts/texturev.lua

@@ -5,7 +5,6 @@ project ("texturev")
 	configuration {}
 
 	includedirs {
-		path.join(BX_DIR,   "include"),
 		path.join(BIMG_DIR, "include"),
 		path.join(BGFX_DIR, "include"),
 		path.join(BGFX_DIR, "3rdparty"),
@@ -23,9 +22,10 @@ project ("texturev")
 		"bimg_decode",
 		"bimg",
 		"bgfx",
-		"bx",
 	}
 
+	using_bx()
+
 	if _OPTIONS["with-sdl"] then
 		defines { "ENTRY_CONFIG_USE_SDL=1" }
 		links   { "SDL2" }

src/bgfx.cpp

@@ -74,7 +74,7 @@ namespace bgfx
 
 		virtual void fatal(const char* _filePath, uint16_t _line, Fatal::Enum _code, const char* _str) override
 		{
-			bgfx::trace(_filePath, _line, "BGFX 0x%08x: %s\n", _code, _str);
+			bgfx::trace(_filePath, _line, "BGFX FATAL 0x%08x: %s\n", _code, _str);
 
 			if (Fatal::DebugCheck == _code)
 			{
@@ -393,7 +393,7 @@ namespace bgfx
 
 		bx::StaticMemoryBlockWriter writer(mem->data, mem->size);
 		uint32_t magic = BGFX_CHUNK_MAGIC_TEX;
-		bx::write(&writer, magic);
+		bx::write(&writer, magic, bx::ErrorAssert{});
 
 		TextureCreate tc;
 		tc.m_width     = _width;
@@ -404,7 +404,7 @@ namespace bgfx
 		tc.m_format    = _format;
 		tc.m_cubeMap   = false;
 		tc.m_mem       = NULL;
-		bx::write(&writer, tc);
+		bx::write(&writer, tc, bx::ErrorAssert{});
 
 		rci->destroyTexture(_handle);
 		rci->createTexture(_handle, mem, _flags, 0);
@@ -442,7 +442,7 @@ namespace bgfx
 
 		if (BX_UNLIKELY(NULL == g_callback) )
 		{
-			bx::debugPrintf("%s(%d): BGFX 0x%08x: %s", _filePath, _line, _code, out);
+			bx::debugPrintf("%s(%d): BGFX FATAL 0x%08x: %s", _filePath, _line, _code, out);
 			abort();
 		}
 		else
@@ -683,13 +683,13 @@ namespace bgfx
 		charsetFillTexture(vga8x8, rgba, 8, pitch, bpp);
 		charsetFillTexture(vga8x16, &rgba[8*pitch], 16, pitch, bpp);
 		m_texture = createTexture2D(width, height, false, 1, TextureFormat::R8
-						, BGFX_SAMPLER_MIN_POINT
-						| BGFX_SAMPLER_MAG_POINT
-						| BGFX_SAMPLER_MIP_POINT
-						| BGFX_SAMPLER_U_CLAMP
-						| BGFX_SAMPLER_V_CLAMP
-						, mem
-						);
+			, BGFX_SAMPLER_MIN_POINT
+			| BGFX_SAMPLER_MAG_POINT
+			| BGFX_SAMPLER_MIP_POINT
+			| BGFX_SAMPLER_U_CLAMP
+			| BGFX_SAMPLER_V_CLAMP
+			, mem
+			);
 
 		ShaderHandle vsh = createEmbeddedShader(s_embeddedShaders, g_caps.rendererType, "vs_debugfont");
 		ShaderHandle fsh = createEmbeddedShader(s_embeddedShaders, g_caps.rendererType, "fs_debugfont");
@@ -3111,14 +3111,15 @@ namespace bgfx
 					}
 
 					bx::MemoryReader reader(mem->data, mem->size);
+					bx::Error err;
 
 					uint32_t magic;
-					bx::read(&reader, magic);
+					bx::read(&reader, magic, &err);
 
 					if (BGFX_CHUNK_MAGIC_TEX == magic)
 					{
 						TextureCreate tc;
-						bx::read(&reader, tc);
+						bx::read(&reader, tc, &err);
 
 						if (NULL != tc.m_mem)
 						{
@@ -3823,11 +3824,14 @@ namespace bgfx
 		BGFX_CHECK_HANDLE_INVALID_OK("setTexture/TextureHandle", s_ctx->m_textureHandle, _handle);
 		BX_ASSERT(_stage < g_caps.limits.maxTextureSamplers, "Invalid stage %d (max %d).", _stage, g_caps.limits.maxTextureSamplers);
 
-		const TextureRef& ref = s_ctx->m_textureRef[_handle.idx];
-		BX_ASSERT(!ref.isReadBack()
-			, "Can't sample from texture which was created with BGFX_TEXTURE_READ_BACK. This is CPU only texture."
-			);
-		BX_UNUSED(ref);
+		if (isValid(_handle) )
+		{
+			const TextureRef& ref = s_ctx->m_textureRef[_handle.idx];
+			BX_ASSERT(!ref.isReadBack()
+				, "Can't sample from texture which was created with BGFX_TEXTURE_READ_BACK. This is CPU only texture."
+				);
+			BX_UNUSED(ref);
+		}
 
 		BGFX_ENCODER(setTexture(_stage, _sampler, _handle, _flags) );
 	}
@@ -4528,7 +4532,7 @@ namespace bgfx
 		return err.isOk();
 	}
 
-	static void isTextureValid(uint16_t _depth, bool _cubeMap, uint16_t _numLayers, TextureFormat::Enum _format, uint64_t _flags, bx::Error* _err)
+	static void isTextureValid(uint16_t _width, uint16_t _height, uint16_t _depth, bool _cubeMap, uint16_t _numLayers, TextureFormat::Enum _format, uint64_t _flags, bx::Error* _err)
 	{
 		BX_ERROR_SCOPE(_err, "Texture validation");
 
@@ -4553,6 +4557,18 @@ namespace bgfx
 			, ""
 			);
 
+		BGFX_ERROR_CHECK(false
+			|| _width  < g_caps.limits.maxTextureSize
+			|| _height < g_caps.limits.maxTextureSize
+			, _err
+			, BGFX_ERROR_TEXTURE_VALIDATION
+			, "Requested texture width/height is above the `maxTextureSize` limit."
+			, "Texture width x height requested %d x %d (Max: %d)."
+			, _width
+			, _height
+			, g_caps.limits.maxTextureSize
+			);
+
 		BGFX_ERROR_CHECK(false
 			|| 0 == (_flags & BGFX_TEXTURE_RT_MASK)
 			|| 0 == (_flags & BGFX_TEXTURE_READ_BACK)
@@ -4572,6 +4588,16 @@ namespace bgfx
 			, ""
 			);
 
+		BGFX_ERROR_CHECK(false
+			|| _numLayers < g_caps.limits.maxTextureLayers
+			, _err
+			, BGFX_ERROR_TEXTURE_VALIDATION
+			, "Requested number of texture array layers is above the `maxTextureLayers` limit."
+			, "Number of texture array layers requested %d (Max: %d)."
+			, _numLayers
+			, g_caps.limits.maxTextureLayers
+			);
+
 		bool formatSupported;
 		if (0 != (_flags & (BGFX_TEXTURE_RT | BGFX_TEXTURE_RT_WRITE_ONLY)) )
 		{
@@ -4619,7 +4645,7 @@ namespace bgfx
 			  formatSupported
 			, _err
 			, BGFX_ERROR_TEXTURE_VALIDATION
-			, "Texture format is not supported!"
+			, "Texture format is not supported! "
 			  "Use bgfx::isTextureValid to check support for texture format before creating it."
 			, "Texture format: %s."
 			, getName(_format)
@@ -4653,7 +4679,7 @@ namespace bgfx
 	bool isTextureValid(uint16_t _depth, bool _cubeMap, uint16_t _numLayers, TextureFormat::Enum _format, uint64_t _flags)
 	{
 		bx::Error err;
-		isTextureValid(_depth, _cubeMap, _numLayers, _format, _flags, &err);
+		isTextureValid(0, 0, _depth, _cubeMap, _numLayers, _format, _flags, &err);
 		return err.isOk();
 	}
 
@@ -4737,15 +4763,6 @@ namespace bgfx
 
 	static TextureHandle createTexture2D(BackbufferRatio::Enum _ratio, uint16_t _width, uint16_t _height, bool _hasMips, uint16_t _numLayers, TextureFormat::Enum _format, uint64_t _flags, const Memory* _mem)
 	{
-		bx::Error err;
-		isTextureValid(0, false, _numLayers, _format, _flags, &err);
-		BGFX_ERROR_ASSERT(&err);
-
-		if (!err.isOk() )
-		{
-			return BGFX_INVALID_HANDLE;
-		}
-
 		if (BackbufferRatio::Count != _ratio)
 		{
 			_width  = uint16_t(s_ctx->m_init.resolution.width);
@@ -4753,6 +4770,14 @@ namespace bgfx
 			getTextureSizeFromRatio(_ratio, _width, _height);
 		}
 
+		bx::ErrorAssert err;
+		isTextureValid(_width, _height, 0, false, _numLayers, _format, _flags, &err);
+
+		if (!err.isOk() )
+		{
+			return BGFX_INVALID_HANDLE;
+		}
+
 		const uint8_t numMips = calcNumMips(_hasMips, _width, _height);
 		_numLayers = bx::max<uint16_t>(_numLayers, 1);
 
@@ -4773,7 +4798,7 @@ namespace bgfx
 
 		bx::StaticMemoryBlockWriter writer(mem->data, mem->size);
 		uint32_t magic = BGFX_CHUNK_MAGIC_TEX;
-		bx::write(&writer, magic);
+		bx::write(&writer, magic, bx::ErrorAssert{});
 
 		TextureCreate tc;
 		tc.m_width     = _width;
@@ -4784,7 +4809,7 @@ namespace bgfx
 		tc.m_format    = _format;
 		tc.m_cubeMap   = false;
 		tc.m_mem       = _mem;
-		bx::write(&writer, tc);
+		bx::write(&writer, tc, bx::ErrorAssert{});
 
 		return s_ctx->createTexture(mem, _flags, 0, NULL, _ratio, NULL != _mem);
 	}
@@ -4803,9 +4828,8 @@ namespace bgfx
 
 	TextureHandle createTexture3D(uint16_t _width, uint16_t _height, uint16_t _depth, bool _hasMips, TextureFormat::Enum _format, uint64_t _flags, const Memory* _mem)
 	{
-		bx::Error err;
-		isTextureValid(_depth, false, 1, _format, _flags, &err);
-		BGFX_ERROR_ASSERT(&err);
+		bx::ErrorAssert err;
+		isTextureValid(_width, _height, _depth, false, 1, _format, _flags, &err);
 
 		if (!err.isOk() )
 		{
@@ -4831,7 +4855,7 @@ namespace bgfx
 
 		bx::StaticMemoryBlockWriter writer(mem->data, mem->size);
 		uint32_t magic = BGFX_CHUNK_MAGIC_TEX;
-		bx::write(&writer, magic);
+		bx::write(&writer, magic, bx::ErrorAssert{});
 
 		TextureCreate tc;
 		tc.m_width     = _width;
@@ -4842,16 +4866,15 @@ namespace bgfx
 		tc.m_format    = _format;
 		tc.m_cubeMap   = false;
 		tc.m_mem       = _mem;
-		bx::write(&writer, tc);
+		bx::write(&writer, tc, bx::ErrorAssert{});
 
 		return s_ctx->createTexture(mem, _flags, 0, NULL, BackbufferRatio::Count, NULL != _mem);
 	}
 
 	TextureHandle createTextureCube(uint16_t _size, bool _hasMips, uint16_t _numLayers, TextureFormat::Enum _format, uint64_t _flags, const Memory* _mem)
 	{
-		bx::Error err;
-		isTextureValid(0, true, _numLayers, _format, _flags, &err);
-		BGFX_ERROR_ASSERT(&err);
+		bx::ErrorAssert err;
+		isTextureValid(_size, _size, 0, true, _numLayers, _format, _flags, &err);
 
 		if (!err.isOk() )
 		{
@@ -4878,7 +4901,7 @@ namespace bgfx
 
 		bx::StaticMemoryBlockWriter writer(mem->data, mem->size);
 		uint32_t magic = BGFX_CHUNK_MAGIC_TEX;
-		bx::write(&writer, magic);
+		bx::write(&writer, magic, bx::ErrorAssert{});
 
 		TextureCreate tc;
 		tc.m_width     = _size;
@@ -4889,7 +4912,7 @@ namespace bgfx
 		tc.m_format    = _format;
 		tc.m_cubeMap   = true;
 		tc.m_mem       = _mem;
-		bx::write(&writer, tc);
+		bx::write(&writer, tc, bx::ErrorAssert{});
 
 		return s_ctx->createTexture(mem, _flags, 0, NULL, BackbufferRatio::Count, NULL != _mem);
 	}

src/bgfx_p.h

@@ -8,16 +8,19 @@
 
 #include <bx/platform.h>
 
-#ifndef BGFX_CONFIG_DEBUG
-#	define BGFX_CONFIG_DEBUG 0
+#ifndef BX_CONFIG_DEBUG
+#	error "BX_CONFIG_DEBUG must be defined in build script!"
 #endif // BGFX_CONFIG_DEBUG
 
-#if BGFX_CONFIG_DEBUG || BX_COMPILER_CLANG_ANALYZER
-#	define BX_TRACE _BX_TRACE
-#	define BX_WARN  _BX_WARN
-#	define BX_ASSERT _BX_ASSERT
-#	define BX_CONFIG_ALLOCATOR_DEBUG 1
-#endif // BGFX_CONFIG_DEBUG
+#define BGFX_CONFIG_DEBUG BX_CONFIG_DEBUG
+
+#if BX_CONFIG_DEBUG
+#	define BX_TRACE  _BGFX_TRACE
+#	define BX_WARN   _BGFX_WARN
+#	define BX_ASSERT _BGFX_ASSERT
+#endif // BX_CONFIG_DEBUG
+
+#	define BX_ASSERT2 _BGFX_ASSERT
 
 #include <bgfx/bgfx.h>
 #include "config.h"
@@ -78,12 +81,12 @@ namespace bgfx
 	inline bool operator==(const UniformHandle& _lhs,    const UniformHandle&    _rhs) { return _lhs.idx == _rhs.idx; }
 }
 
-#define _BX_TRACE(_format, ...)                                                         \
+#define _BGFX_TRACE(_format, ...)                                                       \
 	BX_MACRO_BLOCK_BEGIN                                                                \
 		bgfx::trace(__FILE__, uint16_t(__LINE__), "BGFX " _format "\n", ##__VA_ARGS__); \
 	BX_MACRO_BLOCK_END
 
-#define _BX_WARN(_condition, _format, ...)            \
+#define _BGFX_WARN(_condition, _format, ...)          \
 	BX_MACRO_BLOCK_BEGIN                              \
 		if (!BX_IGNORE_C4127(_condition) )            \
 		{                                             \
@@ -91,11 +94,11 @@ namespace bgfx
 		}                                             \
 	BX_MACRO_BLOCK_END
 
-#define _BX_ASSERT(_condition, _format, ...)                                                            \
+#define _BGFX_ASSERT(_condition, _format, ...)                                                          \
 	BX_MACRO_BLOCK_BEGIN                                                                                \
 		if (!BX_IGNORE_C4127(_condition) )                                                              \
 		{                                                                                               \
-			BX_TRACE("CHECK " _format, ##__VA_ARGS__);                                                  \
+			BX_TRACE("ASSERT " _format, ##__VA_ARGS__);                                                 \
 			bgfx::fatal(__FILE__, uint16_t(__LINE__), bgfx::Fatal::DebugCheck, _format, ##__VA_ARGS__); \
 		}                                                                                               \
 	BX_MACRO_BLOCK_END
@@ -112,25 +115,15 @@ namespace bgfx
 	if (!BX_IGNORE_C4127(_condition) )                                  \
 	{                                                                   \
 		BX_ERROR_SET(_err, _result, _msg);                              \
-		BX_TRACE("%.*s: 0x%08x '%.*s' - " _format                       \
-			, bxErrorScope.getName().getLength()                        \
-			, bxErrorScope.getName().getPtr()                           \
+		BX_TRACE("%S: 0x%08x '%S' - " _format                           \
+			, &bxErrorScope.getName()                                   \
 			, _err->get().code                                          \
-			, _err->getMessage().getLength()                            \
-			, _err->getMessage().getPtr()                               \
+			, &_err->getMessage()                                       \
 			, ##__VA_ARGS__                                             \
 			);                                                          \
 		return;                                                         \
 	}
 
-#define BGFX_ERROR_ASSERT(_err)            \
-	BX_ASSERT((_err)->isOk()               \
-		, "ERROR: 0x%08x '%.*s'."          \
-		, (_err)->get().code               \
-		, (_err)->getMessage().getLength() \
-		, (_err)->getMessage().getPtr()    \
-		);
-
 #include <bx/allocator.h>
 #include <bx/bx.h>
 #include <bx/cpu.h>
@@ -1890,7 +1883,7 @@ namespace bgfx
 
 		bool isReadBack() const
 		{
-			return 0 != (m_flags&BGFX_TEXTURE_READ_BACK);
+			return 0 != (m_flags & BGFX_TEXTURE_READ_BACK);
 		}
 
 		bool isCubeMap() const
@@ -4024,13 +4017,13 @@ namespace bgfx
 				if (!isShaderVerLess(magic, 8) )
 				{
 					uint16_t texInfo;
-					bx::read(&reader, texInfo);
+					bx::read(&reader, texInfo, &err);
 				}
 
 				if (!isShaderVerLess(magic, 10) )
 				{
 					uint16_t texFormat = 0;
-					bx::read(&reader, texFormat);
+					bx::read(&reader, texFormat, &err);
 				}
 
 				PredefinedUniform::Enum predefined = nameToPredefinedUniformEnum(name);
@@ -4079,7 +4072,12 @@ namespace bgfx
 		void setName(Handle _handle, const bx::StringView& _name)
 		{
 			char tmp[1024];
-			uint16_t len = 1+(uint16_t)bx::snprintf(tmp, BX_COUNTOF(tmp), "%sH %d: %.*s", getTypeName(_handle), _handle.idx, _name.getLength(), _name.getPtr() );
+			uint16_t len = 1+(uint16_t)bx::snprintf(tmp, BX_COUNTOF(tmp)
+				, "%sH %d: %S"
+				, getTypeName(_handle)
+				, _handle.idx
+				, &_name
+				);
 
 			CommandBuffer& cmdbuf = getCommandBuffer(CommandBuffer::SetName);
 			cmdbuf.write(_handle);
@@ -4551,9 +4549,8 @@ namespace bgfx
 		{
 			BGFX_MUTEX_SCOPE(m_resourceApiLock);
 
-			bx::Error err;
+			bx::ErrorAssert err;
 			isFrameBufferValid(_num, _attachment, &err);
-			BGFX_ERROR_ASSERT(&err);
 
 			if (!err.isOk() )
 			{
@@ -4692,9 +4689,8 @@ namespace bgfx
 			BGFX_MUTEX_SCOPE(m_resourceApiLock);
 
 			{
-				bx::Error err;
+				bx::ErrorAssert err;
 				isIdentifierValid(_name, &err);
-				BGFX_ERROR_ASSERT(&err);
 
 				if (!err.isOk() )
 				{

src/config.h

@@ -6,7 +6,7 @@
 #ifndef BGFX_CONFIG_H_HEADER_GUARD
 #define BGFX_CONFIG_H_HEADER_GUARD
 
-#include <bx/bx.h>
+#include <bx/bx.h> // bx::isPowerOf2
 
 // # Configuration options for bgfx.
 //
@@ -15,9 +15,9 @@
 //
 // When selecting rendering backends select all backends you want to include in the build.
 
-#ifndef BGFX_CONFIG_DEBUG
-#	define BGFX_CONFIG_DEBUG 0
-#endif // BGFX_CONFIG_DEBUG
+#ifndef BX_CONFIG_DEBUG
+#	error "BX_CONFIG_DEBUG must be defined in build script!"
+#endif // BX_CONFIG_DEBUG
 
 #if !defined(BGFX_CONFIG_RENDERER_AGC)        \
  && !defined(BGFX_CONFIG_RENDERER_DIRECT3D9)  \

src/renderer_gl.cpp

@@ -3383,7 +3383,7 @@ namespace bgfx { namespace gl
 
 			bx::StaticMemoryBlockWriter writer(mem->data, mem->size);
 			uint32_t magic = BGFX_CHUNK_MAGIC_TEX;
-			bx::write(&writer, magic);
+			bx::write(&writer, magic, bx::ErrorAssert{});
 
 			TextureCreate tc;
 			tc.m_width     = _width;
@@ -3394,7 +3394,7 @@ namespace bgfx { namespace gl
 			tc.m_format    = TextureFormat::Enum(texture.m_requestedFormat);
 			tc.m_cubeMap   = false;
 			tc.m_mem       = NULL;
-			bx::write(&writer, tc);
+			bx::write(&writer, tc, bx::ErrorAssert{});
 
 			texture.destroy();
 			texture.create(mem, texture.m_flags, 0);
@@ -4105,10 +4105,11 @@ namespace bgfx { namespace gl
 					void* data = BX_ALLOC(g_allocator, length);
 					if (g_callback->cacheRead(_id, data, length) )
 					{
+						bx::Error err;
 						bx::MemoryReader reader(data, length);
 
 						GLenum format;
-						bx::read(&reader, format);
+						bx::read(&reader, format, &err);
 
 						GL_CHECK(glProgramBinary(programId, format, reader.getDataPtr(), (GLsizei)reader.remaining() ) );
 					}
@@ -5939,11 +5940,13 @@ namespace bgfx { namespace gl
 
 	void ShaderGL::create(const Memory* _mem)
 	{
+		bx::Error err;
+
 		bx::MemoryReader reader(_mem->data, _mem->size);
 		m_hash = bx::hash<bx::HashMurmur2A>(_mem->data, _mem->size);
 
 		uint32_t magic;
-		bx::read(&reader, magic);
+		bx::read(&reader, magic, &err);
 
 		if (isShaderType(magic, 'C') )
 		{
@@ -5959,7 +5962,7 @@ namespace bgfx { namespace gl
 		}
 
 		uint32_t hashIn;
-		bx::read(&reader, hashIn);
+		bx::read(&reader, hashIn, &err);
 
 		uint32_t hashOut;
 
@@ -5969,11 +5972,11 @@ namespace bgfx { namespace gl
 		}
 		else
 		{
-			bx::read(&reader, hashOut);
+			bx::read(&reader, hashOut, &err);
 		}
 
 		uint16_t count;
-		bx::read(&reader, count);
+		bx::read(&reader, count, &err);
 
 		BX_TRACE("%s Shader consts %d"
 			, getShaderTypeName(magic)
@@ -5983,39 +5986,39 @@ namespace bgfx { namespace gl
 		for (uint32_t ii = 0; ii < count; ++ii)
 		{
 			uint8_t nameSize = 0;
-			bx::read(&reader, nameSize);
+			bx::read(&reader, nameSize, &err);
 
 			char name[256];
-			bx::read(&reader, &name, nameSize);
+			bx::read(&reader, &name, nameSize, &err);
 			name[nameSize] = '\0';
 
 			uint8_t type;
-			bx::read(&reader, type);
+			bx::read(&reader, type, &err);
 
 			uint8_t num;
-			bx::read(&reader, num);
+			bx::read(&reader, num, &err);
 
 			uint16_t regIndex;
-			bx::read(&reader, regIndex);
+			bx::read(&reader, regIndex, &err);
 
 			uint16_t regCount;
-			bx::read(&reader, regCount);
+			bx::read(&reader, regCount, &err);
 
 			if (!isShaderVerLess(magic, 8) )
 			{
 				uint16_t texInfo = 0;
-				bx::read(&reader, texInfo);
+				bx::read(&reader, texInfo, &err);
 			}
 
 			if (!isShaderVerLess(magic, 10) )
 			{
 				uint16_t texFormat = 0;
-				bx::read(&reader, texFormat);
+				bx::read(&reader, texFormat, &err);
 			}
 		}
 
 		uint32_t shaderSize;
-		bx::read(&reader, shaderSize);
+		bx::read(&reader, shaderSize, &err);
 
 		m_id = glCreateShader(m_type);
 		BX_WARN(0 != m_id, "Failed to create shader.");
@@ -6031,8 +6034,6 @@ namespace bgfx { namespace gl
 				char* temp = (char*)alloca(tempLen);
 				bx::StaticMemoryBlockWriter writer(temp, tempLen);
 
-				bx::Error err;
-
 				if (BX_ENABLED(BGFX_CONFIG_RENDERER_OPENGLES)
 				&&  !s_renderGL->m_gles3)
 				{
@@ -6041,6 +6042,7 @@ namespace bgfx { namespace gl
 						  "#define flat\n"
 						  "#define noperspective\n"
 						  "#define smooth\n"
+						, &err
 						);
 
 					bool usesDerivatives = s_extension[Extension::OES_standard_derivatives].m_supported
@@ -6060,7 +6062,7 @@ namespace bgfx { namespace gl
 
 					if (usesDerivatives)
 					{
-						bx::write(&writer, "#extension GL_OES_standard_derivatives : enable\n");
+						bx::write(&writer, "#extension GL_OES_standard_derivatives : enable\n", &err);
 					}
 
 					if (usesFragData)
@@ -6069,7 +6071,7 @@ namespace bgfx { namespace gl
 							||  s_extension[Extension::WEBGL_draw_buffers].m_supported
 							, "EXT_draw_buffers is used but not supported by GLES2 driver."
 							);
-						bx::write(&writer, "#extension GL_EXT_draw_buffers : enable\n");
+						bx::write(&writer, "#extension GL_EXT_draw_buffers : enable\n", &err);
 					}
 
 					bool insertFragDepth = false;
@@ -6081,13 +6083,14 @@ namespace bgfx { namespace gl
 							bx::write(&writer
 								, "#extension GL_EXT_frag_depth : enable\n"
 								  "#define bgfx_FragDepth gl_FragDepthEXT\n"
+								, &err
 								);
 
 							char str[128];
 							bx::snprintf(str, BX_COUNTOF(str), "%s float gl_FragDepthEXT;\n"
 								, s_extension[Extension::OES_fragment_precision_high].m_supported ? "highp" : "mediump"
 								);
-							bx::write(&writer, str);
+							bx::write(&writer, str, &err);
 						}
 						else
 						{
@@ -6103,6 +6106,7 @@ namespace bgfx { namespace gl
 								, "#extension GL_EXT_shadow_samplers : enable\n"
 								  "#define shadow2D shadow2DEXT\n"
 								  "#define shadow2DProj shadow2DProjEXT\n"
+								, &err
 								);
 						}
 						else
@@ -6111,13 +6115,14 @@ namespace bgfx { namespace gl
 								, "#define sampler2DShadow sampler2D\n"
 								  "#define shadow2D(_sampler, _coord) step(_coord.z, texture2D(_sampler, _coord.xy).x)\n"
 								  "#define shadow2DProj(_sampler, _coord) step(_coord.z/_coord.w, texture2DProj(_sampler, _coord).x)\n"
+								, &err
 								);
 						}
 					}
 
 					if (usesTexture3D)
 					{
-						bx::write(&writer, "#extension GL_OES_texture_3D : enable\n");
+						bx::write(&writer, "#extension GL_OES_texture_3D : enable\n", &err);
 					}
 
 					if (usesTextureLod)
@@ -6137,6 +6142,7 @@ namespace bgfx { namespace gl
 								  "#define texture2DGrad     texture2DGradARB\n"
 								  "#define texture2DProjGrad texture2DProjGradARB\n"
 								  "#define textureCubeGrad   textureCubeGradARB\n"
+								, &err
 								);
 						}
 						else
@@ -6148,6 +6154,7 @@ namespace bgfx { namespace gl
 									  "#define texture2DLod     texture2DLodEXT\n"
 									  "#define texture2DProjLod texture2DProjLodEXT\n"
 									  "#define textureCubeLod   textureCubeLodEXT\n"
+									, &err
 									);
 							}
 							else
@@ -6156,6 +6163,7 @@ namespace bgfx { namespace gl
 									, "#define texture2DLod(_sampler, _coord, _level) texture2D(_sampler, _coord)\n"
 									  "#define texture2DProjLod(_sampler, _coord, _level) texture2DProj(_sampler, _coord)\n"
 									  "#define textureCubeLod(_sampler, _coord, _level) textureCube(_sampler, _coord)\n"
+									, &err
 									);
 							}
 						}
@@ -6165,11 +6173,11 @@ namespace bgfx { namespace gl
 					{
 						if (s_extension[Extension::INTEL_fragment_shader_ordering].m_supported)
 						{
-							bx::write(&writer, "#extension GL_INTEL_fragment_shader_ordering : enable\n");
+							bx::write(&writer, "#extension GL_INTEL_fragment_shader_ordering : enable\n", &err);
 						}
 						else
 						{
-							bx::write(&writer, "#define beginFragmentShaderOrdering()\n");
+							bx::write(&writer, "#define beginFragmentShaderOrdering()\n", &err);
 						}
 					}
 
@@ -6177,8 +6185,8 @@ namespace bgfx { namespace gl
 						, m_type == GL_FRAGMENT_SHADER ? "mediump" : "highp"
 						);
 
-					bx::write(&writer, code);
-					bx::write(&writer, '\0');
+					bx::write(&writer, code, &err);
+					bx::write(&writer, '\0', &err);
 
 					if (insertFragDepth)
 					{
@@ -6279,66 +6287,67 @@ namespace bgfx { namespace gl
 								  "#define texture2DGrad     texture2DGradARB\n"
 								  "#define texture2DProjGrad texture2DProjGradARB\n"
 								  "#define textureCubeGrad   textureCubeGradARB\n"
+								, &err
 								);
 						}
 					}
 
 					if (usesInstanceID)
 					{
-						bx::write(&writer, "#extension GL_ARB_draw_instanced : enable\n");
+						bx::write(&writer, "#extension GL_ARB_draw_instanced : enable\n", &err);
 					}
 
 					if (usesGpuShader4)
 					{
-						bx::write(&writer, "#extension GL_EXT_gpu_shader4 : enable\n");
+						bx::write(&writer, "#extension GL_EXT_gpu_shader4 : enable\n", &err);
 					}
 
 					if (usesGpuShader5)
 					{
-						bx::write(&writer, "#extension GL_ARB_gpu_shader5 : enable\n");
+						bx::write(&writer, "#extension GL_ARB_gpu_shader5 : enable\n", &err);
 					}
 
 					if (usesViewportLayerArray)
 					{
-						bx::write(&writer, "#extension GL_ARB_shader_viewport_layer_array : enable\n");
+						bx::write(&writer, "#extension GL_ARB_shader_viewport_layer_array : enable\n", &err);
 					}
 
 					if (usesPacking)
 					{
-						bx::write(&writer, "#extension GL_ARB_shading_language_packing : enable\n");
+						bx::write(&writer, "#extension GL_ARB_shading_language_packing : enable\n", &err);
 					}
 
 					if (usesTextureMS)
 					{
-						bx::write(&writer, "#extension GL_ARB_texture_multisample : enable\n");
+						bx::write(&writer, "#extension GL_ARB_texture_multisample : enable\n", &err);
 					}
 
 					if (usesTextureArray)
 					{
-						bx::write(&writer, "#extension GL_EXT_texture_array : enable\n");
+						bx::write(&writer, "#extension GL_EXT_texture_array : enable\n", &err);
 
 						if (BX_ENABLED(BX_PLATFORM_OSX) )
 						{
-							bx::write(&writer, "#define texture2DArrayLod texture2DArray\n");
+							bx::write(&writer, "#define texture2DArrayLod texture2DArray\n", &err);
 						}
 						else
 						{
-							bx::write(&writer, "#define texture2DArrayLodEXT texture2DArrayLod\n");
-							bx::write(&writer, "#define textureArray texture\n");
+							bx::write(&writer, "#define texture2DArrayLodEXT texture2DArrayLod\n", &err);
+							bx::write(&writer, "#define textureArray texture\n", &err);
 						}
 					}
 
 					if (usesTexture3D)
 					{
-						bx::write(&writer, "#define texture3DEXT texture3D\n");
+						bx::write(&writer, "#define texture3DEXT texture3D\n", &err);
 
 						if (BX_ENABLED(BX_PLATFORM_OSX) )
 						{
-							bx::write(&writer, "#define texture3DLodEXT texture3D\n");
+							bx::write(&writer, "#define texture3DLodEXT texture3D\n", &err);
 						}
 						else
 						{
-							bx::write(&writer, "#define texture3DLodEXT texture3DLod\n");
+							bx::write(&writer, "#define texture3DLodEXT texture3DLod\n", &err);
 						}
 					}
 
@@ -6348,12 +6357,12 @@ namespace bgfx { namespace gl
 						{
 							if (m_type == GL_FRAGMENT_SHADER)
 							{
-								bx::write(&writer, "#define varying in\n");
+								bx::write(&writer, "#define varying in\n", &err);
 							}
 							else
 							{
-								bx::write(&writer, "#define attribute in\n");
-								bx::write(&writer, "#define varying out\n");
+								bx::write(&writer, "#define attribute in\n", &err);
+								bx::write(&writer, "#define varying out\n", &err);
 							}
 						}
 
@@ -6374,56 +6383,63 @@ namespace bgfx { namespace gl
 						if (0 != fragData)
 						{
 							bx::write(&writer, &err, "out vec4 bgfx_FragData[%d];\n", fragData);
-							bx::write(&writer, "#define gl_FragData bgfx_FragData\n");
+							bx::write(&writer, "#define gl_FragData bgfx_FragData\n", &err);
 						}
 						else if (!bx::findIdentifierMatch(code, "gl_FragColor").isEmpty() )
 						{
-							bx::write(&writer, "out vec4 bgfx_FragColor;\n");
-							bx::write(&writer, "#define gl_FragColor bgfx_FragColor\n");
+							bx::write(&writer
+								, "out vec4 bgfx_FragColor;\n"
+								  "#define gl_FragColor bgfx_FragColor\n"
+								, &err
+								);
 						}
 					}
 					else
 					{
 						if (m_type == GL_FRAGMENT_SHADER)
 						{
-							bx::write(&writer, "#define in varying\n");
+							bx::write(&writer, "#define in varying\n", &err);
 						}
 						else
 						{
 							bx::write(&writer
 								, "#define in attribute\n"
 								  "#define out varying\n"
+								, &err
 								);
 						}
 					}
 
-					bx::write(&writer,
-						"#define lowp\n"
-						"#define mediump\n"
-						"#define highp\n"
+					bx::write(&writer
+						, "#define lowp\n"
+						  "#define mediump\n"
+						  "#define highp\n"
+						, &err
 						);
 
 					if (!usesInterpQ)
 					{
-						bx::write(&writer,
-							"#define centroid\n"
-							"#define flat\n"
-							"#define noperspective\n"
-							"#define smooth\n"
+						bx::write(&writer
+							,
+							  "#define centroid\n"
+							  "#define flat\n"
+							  "#define noperspective\n"
+							  "#define smooth\n"
+							, &err
 							);
 					}
 
 					if (version == 430)
 					{
 						int32_t verLen = bx::strLen("#version 430\n");
-						bx::write(&writer, code.getPtr()+verLen, code.getLength()-verLen);
+						bx::write(&writer, code.getPtr()+verLen, code.getLength()-verLen, &err);
 					}
 					else
 					{
-						bx::write(&writer, code);
+						bx::write(&writer, code, &err);
 					}
 
-					bx::write(&writer, '\0');
+					bx::write(&writer, '\0', &err);
 				}
 				else if (BX_ENABLED(BGFX_CONFIG_RENDERER_OPENGL   >= 31)
 					 ||  s_renderGL->m_gles3)
@@ -6438,7 +6454,7 @@ namespace bgfx { namespace gl
 					}
 					else
 					{
-						bx::write(&writer, "#version 140\n");
+						bx::write(&writer, "#version 140\n", &err);
 					}
 
 					bx::write(&writer
@@ -6448,6 +6464,7 @@ namespace bgfx { namespace gl
 						  "#define texture2DGrad   textureGrad\n"
 						  "#define texture3DGrad   textureGrad\n"
 						  "#define textureCubeGrad textureGrad\n"
+						, &err
 						);
 
 					if (m_type == GL_FRAGMENT_SHADER)
@@ -6456,21 +6473,31 @@ namespace bgfx { namespace gl
 							, "#define varying       in\n"
 							  "#define texture2D     texture\n"
 							  "#define texture2DProj textureProj\n"
+							, &err
 							);
 
 						if (BX_ENABLED(BGFX_CONFIG_RENDERER_OPENGL) )
 						{
-							bx::write(&writer, "#define shadow2D(_sampler, _coord) vec2(textureProj(_sampler, vec4(_coord, 1.0) ) )\n");
-							bx::write(&writer, "#define shadow2DProj(_sampler, _coord) vec2(textureProj(_sampler, _coord) ) )\n");
+							bx::write(&writer
+								, "#define shadow2D(_sampler, _coord) vec2(textureProj(_sampler, vec4(_coord, 1.0) ) )\n"
+								  "#define shadow2DProj(_sampler, _coord) vec2(textureProj(_sampler, _coord) ) )\n"
+								, &err
+								);
 						}
 						else
 						{
-							bx::write(&writer, "#define shadow2D(_sampler, _coord) (textureProj(_sampler, vec4(_coord, 1.0) ) )\n");
-							bx::write(&writer, "#define shadow2DProj(_sampler, _coord) (textureProj(_sampler, _coord) ) )\n");
+							bx::write(&writer
+								, "#define shadow2D(_sampler, _coord) (textureProj(_sampler, vec4(_coord, 1.0) ) )\n"
+								  "#define shadow2DProj(_sampler, _coord) (textureProj(_sampler, _coord) ) )\n"
+								, &err
+								);
 						}
 
-						bx::write(&writer, "#define texture3D   texture\n");
-						bx::write(&writer, "#define textureCube texture\n");
+						bx::write(&writer
+							, "#define texture3D   texture\n"
+							  "#define textureCube texture\n"
+							, &err
+							);
 
 						uint32_t fragData = 0;
 
@@ -6490,29 +6517,30 @@ namespace bgfx { namespace gl
 						{
 							if (s_extension[Extension::INTEL_fragment_shader_ordering].m_supported)
 							{
-								bx::write(&writer, "#extension GL_INTEL_fragment_shader_ordering : enable\n");
+								bx::write(&writer, "#extension GL_INTEL_fragment_shader_ordering : enable\n", &err);
 							}
 							else
 							{
-								bx::write(&writer, "#define beginFragmentShaderOrdering()\n");
+								bx::write(&writer, "#define beginFragmentShaderOrdering()\n", &err);
 							}
 						}
 
 						if (!bx::findIdentifierMatch(code, s_ARB_texture_multisample).isEmpty() )
 						{
-							bx::write(&writer, "#extension GL_ARB_texture_multisample : enable\n");
+							bx::write(&writer, "#extension GL_ARB_texture_multisample : enable\n", &err);
 						}
 
 						if (0 != fragData)
 						{
 							bx::write(&writer, &err, "out vec4 bgfx_FragData[%d];\n", fragData);
-							bx::write(&writer, "#define gl_FragData bgfx_FragData\n");
+							bx::write(&writer, "#define gl_FragData bgfx_FragData\n", &err);
 						}
 						else
 						{
 							bx::write(&writer
 								, "out vec4 bgfx_FragColor;\n"
 								  "#define gl_FragColor bgfx_FragColor\n"
+								, &err
 								);
 						}
 					}
@@ -6521,6 +6549,7 @@ namespace bgfx { namespace gl
 						bx::write(&writer
 							, "#define attribute in\n"
 							  "#define varying   out\n"
+							, &err
 							);
 					}
 
@@ -6530,11 +6559,12 @@ namespace bgfx { namespace gl
 							, "#define lowp\n"
 							  "#define mediump\n"
 							  "#define highp\n"
+							, &err
 							);
 					}
 
-					bx::write(&writer, code.getPtr(), code.getLength() );
-					bx::write(&writer, '\0');
+					bx::write(&writer, code.getPtr(), code.getLength(), &err);
+					bx::write(&writer, '\0', &err);
 				}
 
 				code.set(temp);
@@ -6557,11 +6587,12 @@ namespace bgfx { namespace gl
 					  "#define texture2DGrad            textureGrad\n"
 					  "#define texture3DGrad            textureGrad\n"
 					  "#define textureCubeGrad          textureGrad\n"
+					, &err
 					);
 
 				int32_t verLen = bx::strLen("#version 430\n");
-				bx::write(&writer, code.getPtr()+verLen, codeLen-verLen);
-				bx::write(&writer, '\0');
+				bx::write(&writer, code.getPtr()+verLen, codeLen-verLen, &err);
+				bx::write(&writer, '\0', &err);
 
 				code = temp;
 			}

src/renderer_vk.cpp

@@ -2267,7 +2267,7 @@ VK_IMPORT_DEVICE
 
 			bx::StaticMemoryBlockWriter writer(mem->data, mem->size);
 			uint32_t magic = BGFX_CHUNK_MAGIC_TEX;
-			bx::write(&writer, magic);
+			bx::write(&writer, magic, bx::ErrorAssert{});
 
 			TextureCreate tc;
 			tc.m_width     = _width;
@@ -2278,7 +2278,7 @@ VK_IMPORT_DEVICE
 			tc.m_format    = format;
 			tc.m_cubeMap   = false;
 			tc.m_mem       = NULL;
-			bx::write(&writer, tc);
+			bx::write(&writer, tc, bx::ErrorAssert{});
 
 			destroyTexture(_handle);
 			createTexture(_handle, mem, flags, 0);
@@ -4688,10 +4688,12 @@ VK_DESTROY
 
 	void ShaderVK::create(const Memory* _mem)
 	{
+		bx::Error err;
+
 		bx::MemoryReader reader(_mem->data, _mem->size);
 
 		uint32_t magic;
-		bx::read(&reader, magic);
+		bx::read(&reader, magic, &err);
 
 		VkShaderStageFlagBits shaderStage = VK_SHADER_STAGE_ALL;
 
@@ -4711,7 +4713,7 @@ VK_DESTROY
 		const bool fragment = isShaderType(magic, 'F');
 
 		uint32_t hashIn;
-		bx::read(&reader, hashIn);
+		bx::read(&reader, hashIn, &err);
 
 		uint32_t hashOut;
 
@@ -4721,15 +4723,15 @@ VK_DESTROY
 		}
 		else
 		{
-			bx::read(&reader, hashOut);
+			bx::read(&reader, hashOut, &err);
 		}
 
 		uint16_t count;
-		bx::read(&reader, count);
+		bx::read(&reader, count, &err);
 
 		m_numPredefined = 0;
-		m_numUniforms = count;
-		m_numTextures = 0;
+		m_numUniforms   = count;
+		m_numTextures   = 0;
 
 		m_oldBindingModel = isShaderVerLess(magic, 11);
 
@@ -4754,46 +4756,44 @@ VK_DESTROY
 			for (uint32_t ii = 0; ii < count; ++ii)
 			{
 				uint8_t nameSize = 0;
-				bx::read(&reader, nameSize);
+				bx::read(&reader, nameSize, &err);
 
 				char name[256];
-				bx::read(&reader, &name, nameSize);
+				bx::read(&reader, &name, nameSize, &err);
 				name[nameSize] = '\0';
 
 				uint8_t type = 0;
-				bx::read(&reader, type);
+				bx::read(&reader, type, &err);
 
 				uint8_t num;
-				bx::read(&reader, num);
+				bx::read(&reader, num, &err);
 
 				uint16_t regIndex;
-				bx::read(&reader, regIndex);
+				bx::read(&reader, regIndex, &err);
 
 				uint16_t regCount;
-				bx::read(&reader, regCount);
+				bx::read(&reader, regCount, &err);
 
-				const bool hasTexData = !isShaderVerLess(magic, 8);
+				const bool hasTexData   = !isShaderVerLess(magic, 8);
 				const bool hasTexFormat = !isShaderVerLess(magic, 10);
-				uint8_t texComponent = 0;
-				uint8_t texDimension = 0;
-				uint16_t texFormat = 0;
+				uint8_t  texComponent   = 0;
+				uint8_t  texDimension   = 0;
+				uint16_t texFormat      = 0;
 
 				if (hasTexData)
 				{
-					bx::read(&reader, texComponent);
-					bx::read(&reader, texDimension);
+					bx::read(&reader, texComponent, &err);
+					bx::read(&reader, texDimension, &err);
 				}
 
 				if (hasTexFormat)
 				{
-					bx::read(&reader, texFormat);
+					bx::read(&reader, texFormat, &err);
 				}
 
 				const char* kind = "invalid";
 
-				BX_UNUSED(num);
-				BX_UNUSED(texComponent);
-				BX_UNUSED(texFormat);
+				BX_UNUSED(num, texComponent, texFormat);
 
 				auto textureDimensionToViewType = [](TextureDimension::Enum dimension)
 				{
@@ -4923,7 +4923,7 @@ VK_DESTROY
 		}
 
 		uint32_t shaderSize;
-		bx::read(&reader, shaderSize);
+		bx::read(&reader, shaderSize, &err);
 
 		const void* code = reader.getDataPtr();
 		bx::skip(&reader, shaderSize+1);
@@ -4950,12 +4950,12 @@ VK_DESTROY
 		bx::memSet(m_attrMask,  0, sizeof(m_attrMask) );
 		bx::memSet(m_attrRemap, 0, sizeof(m_attrRemap) );
 
-		bx::read(&reader, m_numAttrs);
+		bx::read(&reader, m_numAttrs, &err);
 
 		for (uint8_t ii = 0; ii < m_numAttrs; ++ii)
 		{
 			uint16_t id;
-			bx::read(&reader, id);
+			bx::read(&reader, id, &err);
 
 			Attrib::Enum attr = idToAttrib(id);
 
@@ -4976,7 +4976,7 @@ VK_DESTROY
 		murmur.add(m_attrRemap, m_numAttrs);
 		m_hash = murmur.end();
 
-		bx::read(&reader, m_size);
+		bx::read(&reader, m_size, &err);
 
 		// fill binding description with uniform informations
 		uint16_t bidx = 0;

src/shader.cpp

@@ -121,8 +121,10 @@ namespace bgfx
 		bx::WriterI* writer = reinterpret_cast<bx::WriterI*>(_userData);
 		char temp[512];
 		toString(temp, sizeof(temp), _instruction);
-		bx::write(writer, temp, (int32_t)bx::strLen(temp) );
-		bx::write(writer, '\n');
+
+		bx::Error err;
+		bx::write(writer, temp, (int32_t)bx::strLen(temp), &err);
+		bx::write(writer, '\n', &err);
 		return true;
 	}
 
@@ -132,8 +134,10 @@ namespace bgfx
 		bx::WriterI* writer = reinterpret_cast<bx::WriterI*>(_userData);
 		char temp[512];
 		toString(temp, sizeof(temp), _instruction);
-		bx::write(writer, temp, (int32_t)bx::strLen(temp) );
-		bx::write(writer, '\n');
+
+		bx::Error err;
+		bx::write(writer, temp, (int32_t)bx::strLen(temp), &err);
+		bx::write(writer, '\n', &err);
 		return true;
 	}
 
@@ -143,15 +147,17 @@ namespace bgfx
 		bx::WriterI* writer = reinterpret_cast<bx::WriterI*>(_userData);
 		char temp[512];
 		toString(temp, sizeof(temp), _instruction);
-		bx::write(writer, temp, (int32_t)bx::strLen(temp) );
-		bx::write(writer, '\n');
+
+		bx::Error err;
+		bx::write(writer, temp, (int32_t)bx::strLen(temp), &err);
+		bx::write(writer, '\n', &err);
 		return true;
 	}
 
 	void disassembleByteCode(bx::WriterI* _writer, bx::ReaderSeekerI* _reader, bx::Error* _err)
 	{
 		uint32_t magic;
-		bx::peek(_reader, magic);
+		bx::peek(_reader, magic, _err);
 
 		if (magic == SPV_CHUNK_HEADER)
 		{
@@ -178,14 +184,14 @@ namespace bgfx
 		BX_ERROR_SCOPE(_err);
 
 		uint32_t magic;
-		bx::peek(_reader, magic);
+		bx::peek(_reader, magic, _err);
 
 		if (isShaderBin(magic) )
 		{
-			bx::read(_reader, magic);
+			bx::read(_reader, magic, _err);
 
 			uint32_t hashIn;
-			bx::read(_reader, hashIn);
+			bx::read(_reader, hashIn, _err);
 
 			uint32_t hashOut;
 
@@ -195,7 +201,7 @@ namespace bgfx
 			}
 			else
 			{
-				bx::read(_reader, hashOut);
+				bx::read(_reader, hashOut, _err);
 			}
 
 			uint16_t count;

src/shader_dxbc.cpp

@@ -1066,7 +1066,7 @@ namespace bgfx
 
 		_instruction.opcode = DxbcOpcode::Enum( (token & UINT32_C(0x000007ff) )      );
 		BX_ASSERT(_instruction.opcode < DxbcOpcode::Enum::Count, "unknown opcode");
-		
+
 		_instruction.length =          uint8_t( (token & UINT32_C(0x7f000000) ) >> 24);
 		bool extended       =              0 != (token & UINT32_C(0x80000000) );
 
@@ -1281,7 +1281,7 @@ namespace bgfx
 					size += read(_reader, tableId, _err);
 
 					uint32_t num;
-					size += read(_reader, num);
+					size += read(_reader, num, _err);
 
 					for (uint32_t ii = 0; ii < num; ++ii)
 					{
@@ -1358,7 +1358,7 @@ namespace bgfx
 					token &= UINT32_C(0x000007ff);
 					token |= _instruction.customDataClass << 11;
 
-					size += bx::write(_writer, token);
+					size += bx::write(_writer, token, _err);
 
 					uint32_t len = uint32_t(_instruction.customData.size()*sizeof(uint32_t) );
 					size += bx::write(_writer, len/4+2, _err);
@@ -1410,7 +1410,7 @@ namespace bgfx
 				break;
 		}
 
-		size += bx::write(_writer, token);
+		size += bx::write(_writer, token, _err);
 
 		for (uint32_t ii = 0; _instruction.extended[ii] != DxbcInstruction::ExtendedType::Count; ++ii)
 		{
@@ -1734,7 +1734,7 @@ namespace bgfx
 			DxbcSignature::Element element;
 
 			uint32_t nameOffset;
-			size += bx::read(_reader, nameOffset);
+			size += bx::read(_reader, nameOffset, _err);
 
 			char name[DXBC_MAX_NAME_STRING];
 			readString(_reader, offset + nameOffset, name, DXBC_MAX_NAME_STRING, _err);
@@ -1784,7 +1784,7 @@ namespace bgfx
 			}
 			else
 			{
-				size += bx::write(_writer, it->second);
+				size += bx::write(_writer, it->second, _err);
 			}
 
 			size += bx::write(_writer, element.semanticIndex, _err);
@@ -1979,7 +1979,7 @@ namespace bgfx
 		}
 
 		int64_t dxbcOffset = bx::seek(_writer);
-		size += bx::write(_writer, DXBC_CHUNK_HEADER);
+		size += bx::write(_writer, DXBC_CHUNK_HEADER, _err);
 
 		size += bx::writeRep(_writer, 0, 16, _err);
 

tools/geometryc/geometryc.cpp

@@ -165,7 +165,13 @@ void optimizeVertexCache(uint16_t* _indices, uint32_t _numIndices, uint32_t _num
 	delete[] newIndexList;
 }
 
-uint32_t optimizeVertexFetch(uint16_t* _indices, uint32_t _numIndices, uint8_t* _vertexData, uint32_t _numVertices, uint16_t _stride)
+uint32_t optimizeVertexFetch(
+	  uint16_t* _indices
+	, uint32_t _numIndices
+	, uint8_t* _vertexData
+	, uint32_t _numVertices
+	, uint16_t _stride
+	)
 {
 	unsigned char* newVertices = (unsigned char*)malloc(_numVertices * _stride );
 	size_t vertexCount = meshopt_optimizeVertexFetch(newVertices, _indices, _numIndices, _vertexData, _numVertices, _stride);
@@ -175,35 +181,53 @@ uint32_t optimizeVertexFetch(uint16_t* _indices, uint32_t _numIndices, uint8_t*
 	return uint32_t(vertexCount);
 }
 
-void writeCompressedIndices(bx::WriterI* _writer, const uint16_t* _indices, uint32_t _numIndices, uint32_t _numVertices)
+void writeCompressedIndices(
+	  bx::WriterI* _writer
+	, const uint16_t* _indices
+	, uint32_t _numIndices
+	, uint32_t _numVertices
+	, bx::Error* _err
+	)
 {
 	size_t maxSize = meshopt_encodeIndexBufferBound(_numIndices, _numVertices);
 	unsigned char* compressedIndices = (unsigned char*)malloc(maxSize);
+
 	size_t compressedSize = meshopt_encodeIndexBuffer(compressedIndices, maxSize, _indices, _numIndices);
+
 	bx::printf("Indices uncompressed: %10d, compressed: %10d, ratio: %0.2f%%\n"
 		, _numIndices*2
 		, (uint32_t)compressedSize
 		, 100.0f - float(compressedSize ) / float(_numIndices*2)*100.0f
 		);
 
-	bx::write(_writer, (uint32_t)compressedSize);
-	bx::write(_writer, compressedIndices, (uint32_t)compressedSize );
+	bx::write(_writer, (uint32_t)compressedSize, _err);
+	bx::write(_writer, compressedIndices, (uint32_t)compressedSize, _err);
+
 	free(compressedIndices);
 }
 
-void writeCompressedVertices(bx::WriterI* _writer,  const uint8_t* _vertices, uint32_t _numVertices, uint16_t _stride)
+void writeCompressedVertices(
+	  bx::WriterI* _writer
+	, const uint8_t* _vertices
+	, uint32_t _numVertices
+	, uint16_t _stride
+	, bx::Error* _err
+	)
 {
 	size_t maxSize = meshopt_encodeVertexBufferBound(_numVertices, _stride);
 	unsigned char* compressedVertices = (unsigned char*)malloc(maxSize);
+
 	size_t compressedSize = meshopt_encodeVertexBuffer(compressedVertices, maxSize, _vertices, _numVertices, _stride);
+
 	bx::printf("Vertices uncompressed: %10d, compressed: %10d, ratio: %0.2f%%\n"
 		, _numVertices * _stride
 		, (uint32_t)compressedSize
 		, 100.0f - float(compressedSize) / float(_numVertices * _stride)*100.0f
 		);
 
-	bx::write(_writer, (uint32_t)compressedSize);
-	bx::write(_writer, compressedVertices, (uint32_t)compressedSize );
+	bx::write(_writer, (uint32_t)compressedSize, _err);
+	bx::write(_writer, compressedVertices, (uint32_t)compressedSize, _err);
+
 	free(compressedVertices);
 }
 
@@ -304,7 +328,13 @@ void calcTangents(void* _vertices, uint16_t _numVertices, bgfx::VertexLayout _la
 	delete [] tangents;
 }
 
-void write(bx::WriterI* _writer, const void* _vertices, uint32_t _numVertices, uint32_t _stride)
+void write(
+	  bx::WriterI* _writer
+	, const void* _vertices
+	, uint32_t _numVertices
+	, uint32_t _stride
+	, bx::Error* _err
+	)
 {
 	bx::Sphere maxSphere;
 	bx::calcMaxBoundingSphere(maxSphere, _vertices, _numVertices, _stride);
@@ -314,20 +344,20 @@ void write(bx::WriterI* _writer, const void* _vertices, uint32_t _numVertices, u
 
 	if (minSphere.radius > maxSphere.radius)
 	{
-		bx::write(_writer, maxSphere);
+		bx::write(_writer, maxSphere, _err);
 	}
 	else
 	{
-		bx::write(_writer, minSphere);
+		bx::write(_writer, minSphere, _err);
 	}
 
 	bx::Aabb aabb;
 	bx::toAabb(aabb, _vertices, _numVertices, _stride);
-	bx::write(_writer, aabb);
+	bx::write(_writer, aabb, _err);
 
 	bx::Obb obb;
 	bx::calcObb(obb, _vertices, _numVertices, _stride, s_obbSteps);
-	bx::write(_writer, obb);
+	bx::write(_writer, obb, _err);
 }
 
 void write(
@@ -340,6 +370,7 @@ void write(
 	, bool _compress
 	, const stl::string& _material
 	, const PrimitiveArray& _primitives
+	, bx::Error* _err
 	)
 {
 	using namespace bx;
@@ -349,54 +380,58 @@ void write(
 
 	if (_compress)
 	{
-		write(_writer, kChunkVertexBufferCompressed);
-		write(_writer, _vertices, _numVertices, stride);
+		write(_writer, kChunkVertexBufferCompressed, _err);
+		write(_writer, _vertices, _numVertices, stride, _err);
 
 		write(_writer, _layout);
 
-		write(_writer, uint16_t(_numVertices) );
-		writeCompressedVertices(_writer, _vertices, _numVertices, uint16_t(stride) );
+		write(_writer, uint16_t(_numVertices), _err);
+		writeCompressedVertices(_writer, _vertices, _numVertices, uint16_t(stride), _err);
 	}
 	else
 	{
-		write(_writer, kChunkVertexBuffer);
-		write(_writer, _vertices, _numVertices, stride);
+		write(_writer, kChunkVertexBuffer, _err);
+		write(_writer, _vertices, _numVertices, stride, _err);
 
-		write(_writer, _layout);
+		write(_writer, _layout, _err);
 
-		write(_writer, uint16_t(_numVertices) );
-		write(_writer, _vertices, _numVertices*stride);
+		write(_writer, uint16_t(_numVertices), _err);
+		write(_writer, _vertices, _numVertices*stride, _err);
 	}
 
 	if (_compress)
 	{
-		write(_writer, kChunkIndexBufferCompressed);
-		write(_writer, _numIndices);
-		writeCompressedIndices(_writer, _indices, _numIndices, _numVertices);
+		write(_writer, kChunkIndexBufferCompressed, _err);
+		write(_writer, _numIndices, _err);
+
+		writeCompressedIndices(_writer, _indices, _numIndices, _numVertices, _err);
 	}
 	else
 	{
-		write(_writer, kChunkIndexBuffer);
-		write(_writer, _numIndices);
-		write(_writer, _indices, _numIndices*2);
+		write(_writer, kChunkIndexBuffer, _err);
+		write(_writer, _numIndices, _err);
+		write(_writer, _indices, _numIndices*2, _err);
 	}
 
-	write(_writer, kChunkPrimitive);
+	write(_writer, kChunkPrimitive, _err);
+
 	uint16_t nameLen = uint16_t(_material.size() );
-	write(_writer, nameLen);
-	write(_writer, _material.c_str(), nameLen);
-	write(_writer, uint16_t(_primitives.size() ) );
+	write(_writer, nameLen, _err);
+
+	write(_writer, _material.c_str(), nameLen, _err);
+	write(_writer, uint16_t(_primitives.size() ), _err);
+
 	for (PrimitiveArray::const_iterator primIt = _primitives.begin(); primIt != _primitives.end(); ++primIt)
 	{
 		const Primitive& prim = *primIt;
 		nameLen = uint16_t(prim.m_name.size() );
-		write(_writer, nameLen);
-		write(_writer, prim.m_name.c_str(), nameLen);
-		write(_writer, prim.m_startIndex);
-		write(_writer, prim.m_numIndices);
-		write(_writer, prim.m_startVertex);
-		write(_writer, prim.m_numVertices);
-		write(_writer, &_vertices[prim.m_startVertex*stride], prim.m_numVertices, stride);
+		write(_writer, nameLen, _err);
+		write(_writer, prim.m_name.c_str(), nameLen, _err);
+		write(_writer, prim.m_startIndex, _err);
+		write(_writer, prim.m_numIndices, _err);
+		write(_writer, prim.m_startVertex, _err);
+		write(_writer, prim.m_numVertices, _err);
+		write(_writer, &_vertices[prim.m_startVertex*stride], prim.m_numVertices, stride, _err);
 	}
 }
 
@@ -1023,7 +1058,7 @@ int main(int _argc, const char* _argv[])
 
 	uint32_t size = (uint32_t)bx::getSize(&fr);
 	char* data = new char[size+1];
-	size = bx::read(&fr, data, size);
+	size = bx::read(&fr, data, size, bx::ErrorAssert{});
 	data[size] = '\0';
 	bx::close(&fr);
 
@@ -1225,18 +1260,22 @@ int main(int _argc, const char* _argv[])
 	sentinelGroup.m_numTriangles = UINT32_MAX;
 	mesh.m_groups.push_back(sentinelGroup);
 
+	bx::Error err;
+
 	uint32_t ii = 0;
 	for (GroupArray::const_iterator groupIt = mesh.m_groups.begin(); groupIt != mesh.m_groups.end(); ++groupIt, ++ii)
 	{
-		bool sentinel = groupIt->m_startTriangle == 0 && groupIt->m_numTriangles == UINT32_MAX;
+		const bool sentinel = groupIt->m_startTriangle == 0 && groupIt->m_numTriangles == UINT32_MAX;
+
 		for (uint32_t tri = groupIt->m_startTriangle, end = tri + groupIt->m_numTriangles; tri < end; ++tri)
 		{
 			if (0 != bx::strCmp(material.c_str(), groupIt->m_material.c_str() )
-			|| sentinel
+			||  sentinel
 			||  65533 <= numVertices)
 			{
 				prim.m_numVertices = numVertices - prim.m_startVertex;
 				prim.m_numIndices  = numIndices  - prim.m_startIndex;
+
 				if (0 < prim.m_numVertices)
 				{
 					primitives.push_back(prim);
@@ -1248,27 +1287,31 @@ int main(int _argc, const char* _argv[])
 				}
 
 				triReorderElapsed -= bx::getHPCounter();
+
 				for (PrimitiveArray::const_iterator primIt = primitives.begin(); primIt != primitives.end(); ++primIt)
 				{
 					const Primitive& prim1 = *primIt;
 					optimizeVertexCache(indexData + prim1.m_startIndex, prim1.m_numIndices, numVertices);
 				}
+
 				numVertices = optimizeVertexFetch(indexData, numIndices, vertexData, numVertices, uint16_t(stride) );
 
 				triReorderElapsed += bx::getHPCounter();
 
-				if ( numVertices > 0 && numIndices > 0 )
+				if (0 < numVertices
+				&&  0 < numIndices)
 				{
 					write(&writer
-						  , vertexData
-						  , numVertices
-						  , layout
-						  , indexData
-						  , numIndices
-						  , compress
-						  , material
-						  , primitives
-						  );
+						, vertexData
+						, numVertices
+						, layout
+						, indexData
+						, numIndices
+						, compress
+						, material
+						, primitives
+						, &err
+						);
 				}
 				primitives.clear();
 
@@ -1288,7 +1331,9 @@ int main(int _argc, const char* _argv[])
 				material = groupIt->m_material;
 
 				if (sentinel)
+				{
 					break;
+				}
 			}
 
 			TriIndices& triangle = mesh.m_triangles[tri];

tools/geometryv/geometryv.cpp

@@ -430,7 +430,7 @@ struct View
 		{
 			m_path = _filePath;
 		}
-		else if (bx::open(&dr, _filePath.getPath() ) )
+		else if (bx::open(&dr, _filePath.getPath()) )
 		{
 			m_path = _filePath.getPath();
 		}
@@ -515,7 +515,7 @@ struct View
 		bx::FileReader reader;
 		if (bx::open(&reader, filePath) )
 		{
-			bx::read(&reader, settings);
+			bx::read(&reader, settings, bx::ErrorAssert{});
 			bx::close(&reader);
 
 			if (!bx::fromString(&m_width, settings.get("view/width") ) )
@@ -550,7 +550,7 @@ struct View
 			bx::FileWriter writer;
 			if (bx::open(&writer, filePath) )
 			{
-				bx::write(&writer, settings);
+				bx::write(&writer, settings, bx::ErrorAssert{});
 				bx::close(&writer);
 			}
 		}

tools/shaderc/shaderc.cpp

@@ -443,7 +443,7 @@ namespace bgfx
 			len = bx::vsnprintf(out, len, _format, argList);
 		}
 
-		len = bx::write(_writer, out, len);
+		len = bx::write(_writer, out, len, bx::ErrorAssert{});
 
 		va_end(argList);
 
@@ -538,8 +538,7 @@ namespace bgfx
 				len = bx::vsnprintf(out, len, _format, argList);
 			}
 
-			bx::Error err;
-			int32_t size = bx::FileWriter::write(out, len, &err);
+			int32_t size = bx::FileWriter::write(out, len, bx::ErrorAssert{});
 
 			va_end(argList);
 
@@ -584,7 +583,7 @@ namespace bgfx
 			{
 				m_size = (uint32_t)bx::getSize(&reader);
 				m_data = new char[m_size+1];
-				m_size = (uint32_t)bx::read(&reader, m_data, m_size);
+				m_size = (uint32_t)bx::read(&reader, m_data, m_size, bx::ErrorAssert{});
 				bx::close(&reader);
 
 				if (m_data[0] == '\xef'
@@ -686,7 +685,7 @@ namespace bgfx
 		bx::FileWriter out;
 		if (bx::open(&out, _filePath) )
 		{
-			bx::write(&out, _data, _size);
+			bx::write(&out, _data, _size, bx::ErrorAssert{});
 			bx::close(&out);
 		}
 	}
@@ -1352,6 +1351,7 @@ namespace bgfx
 		InOut shaderOutputs;
 		uint32_t inputHash = 0;
 		uint32_t outputHash = 0;
+		bx::ErrorAssert err;
 
 		char* data;
 		char* input;
@@ -1443,31 +1443,31 @@ namespace bgfx
 		{
 			if ('f' == _options.shaderType)
 			{
-				bx::write(_writer, BGFX_CHUNK_MAGIC_FSH);
+				bx::write(_writer, BGFX_CHUNK_MAGIC_FSH, &err);
 			}
 			else if ('v' == _options.shaderType)
 			{
-				bx::write(_writer, BGFX_CHUNK_MAGIC_VSH);
+				bx::write(_writer, BGFX_CHUNK_MAGIC_VSH, &err);
 			}
 			else
 			{
-				bx::write(_writer, BGFX_CHUNK_MAGIC_CSH);
+				bx::write(_writer, BGFX_CHUNK_MAGIC_CSH, &err);
 			}
 
-			bx::write(_writer, inputHash);
-			bx::write(_writer, outputHash);
+			bx::write(_writer, inputHash, &err);
+			bx::write(_writer, outputHash, &err);
 		}
 
 		if (raw)
 		{
 			if (profile->lang == ShadingLang::GLSL)
 			{
-				bx::write(_writer, uint16_t(0) );
+				bx::write(_writer, uint16_t(0), &err);
 
 				uint32_t shaderSize = (uint32_t)bx::strLen(input);
-				bx::write(_writer, shaderSize);
-				bx::write(_writer, input, shaderSize);
-				bx::write(_writer, uint8_t(0) );
+				bx::write(_writer, shaderSize, &err);
+				bx::write(_writer, input, shaderSize, &err);
+				bx::write(_writer, uint8_t(0), &err);
 
 				compiled = true;
 			}
@@ -1579,7 +1579,12 @@ namespace bgfx
 				{
 					if (_options.preprocessOnly)
 					{
-						bx::write(_writer, preprocessor.m_preprocessed.c_str(), (int32_t)preprocessor.m_preprocessed.size() );
+						bx::write(
+							  _writer
+							, preprocessor.m_preprocessed.c_str()
+							, (int32_t)preprocessor.m_preprocessed.size()
+							, &err
+							);
 
 						return true;
 					}
@@ -1587,9 +1592,9 @@ namespace bgfx
 					{
 						std::string code;
 
-						bx::write(_writer, BGFX_CHUNK_MAGIC_CSH);
-						bx::write(_writer, uint32_t(0) );
-						bx::write(_writer, outputHash);
+						bx::write(_writer, BGFX_CHUNK_MAGIC_CSH, &err);
+						bx::write(_writer, uint32_t(0), &err);
+						bx::write(_writer, outputHash, &err);
 
 						if (profile->lang == ShadingLang::GLSL
 						||  profile->lang == ShadingLang::ESSL)
@@ -1607,23 +1612,16 @@ namespace bgfx
 									);
 							}
 
-#if 1
 							code += preprocessor.m_preprocessed;
 
-							bx::write(_writer, uint16_t(0) );
+							bx::write(_writer, uint16_t(0), &err);
 
 							uint32_t shaderSize = (uint32_t)code.size();
-							bx::write(_writer, shaderSize);
-							bx::write(_writer, code.c_str(), shaderSize);
-							bx::write(_writer, uint8_t(0) );
+							bx::write(_writer, shaderSize, &err);
+							bx::write(_writer, code.c_str(), shaderSize, &err);
+							bx::write(_writer, uint8_t(0), &err);
 
 							compiled = true;
-#else
-							code += _comment;
-							code += preprocessor.m_preprocessed;
-
-							compiled = compileGLSLShader(cmdLine, essl, code, writer);
-#endif // 0
 						}
 						else
 						{
@@ -2108,12 +2106,14 @@ namespace bgfx
 
 				if (preprocessor.run(input) )
 				{
-					//BX_TRACE("Input file: %s", filePath);
-					//BX_TRACE("Output file: %s", outFilePath);
-
 					if (_options.preprocessOnly)
 					{
-						bx::write(_writer, preprocessor.m_preprocessed.c_str(), (int32_t)preprocessor.m_preprocessed.size() );
+						bx::write(
+							  _writer
+							, preprocessor.m_preprocessed.c_str()
+							, (int32_t)preprocessor.m_preprocessed.size()
+							, &err
+							);
 
 						return true;
 					}
@@ -2123,21 +2123,21 @@ namespace bgfx
 
 						if ('f' == _options.shaderType)
 						{
-							bx::write(_writer, BGFX_CHUNK_MAGIC_FSH);
-							bx::write(_writer, inputHash);
-							bx::write(_writer, uint32_t(0) );
+							bx::write(_writer, BGFX_CHUNK_MAGIC_FSH, &err);
+							bx::write(_writer, inputHash, &err);
+							bx::write(_writer, uint32_t(0), &err);
 						}
 						else if ('v' == _options.shaderType)
 						{
-							bx::write(_writer, BGFX_CHUNK_MAGIC_VSH);
-							bx::write(_writer, uint32_t(0) );
-							bx::write(_writer, outputHash);
+							bx::write(_writer, BGFX_CHUNK_MAGIC_VSH, &err);
+							bx::write(_writer, uint32_t(0), &err);
+							bx::write(_writer, outputHash, &err);
 						}
 						else
 						{
-							bx::write(_writer, BGFX_CHUNK_MAGIC_CSH);
-							bx::write(_writer, uint32_t(0) );
-							bx::write(_writer, outputHash);
+							bx::write(_writer, BGFX_CHUNK_MAGIC_CSH, &err);
+							bx::write(_writer, uint32_t(0), &err);
+							bx::write(_writer, outputHash, &err);
 						}
 
 						if (profile->lang == ShadingLang::GLSL
@@ -2448,7 +2448,7 @@ namespace bgfx
 											"		, vec4(v0.w, v1.w, v2.w, v3.w)\n"
 											"		);\n"
 											"}\n"
-											;											
+											;
 									}
 								}
 							}
@@ -2483,12 +2483,12 @@ namespace bgfx
 							{
 								code += preprocessor.m_preprocessed;
 
-								bx::write(_writer, uint16_t(0) );
+								bx::write(_writer, uint16_t(0), &err);
 
 								uint32_t shaderSize = (uint32_t)code.size();
-								bx::write(_writer, shaderSize);
-								bx::write(_writer, code.c_str(), shaderSize);
-								bx::write(_writer, uint8_t(0) );
+								bx::write(_writer, shaderSize, &err);
+								bx::write(_writer, code.c_str(), shaderSize, &err);
+								bx::write(_writer, uint8_t(0), &err);
 
 								compiled = true;
 							}
@@ -2745,7 +2745,7 @@ namespace bgfx
 			const size_t padding    = 16384;
 			uint32_t size = (uint32_t)bx::getSize(&reader);
 			char* data = new char[size+padding+1];
-			size = (uint32_t)bx::read(&reader, data, size);
+			size = (uint32_t)bx::read(&reader, data, size, bx::ErrorAssert{});
 
 			if (data[0] == '\xef'
 			&&  data[1] == '\xbb'

tools/shaderc/shaderc.h

@@ -11,35 +11,6 @@ namespace bgfx
 	extern bool g_verbose;
 }
 
-#define _BX_TRACE(_format, ...)                                                          \
-				BX_MACRO_BLOCK_BEGIN                                                     \
-					if (bgfx::g_verbose)                                                 \
-					{                                                                    \
-						bx::printf(BX_FILE_LINE_LITERAL "" _format "\n", ##__VA_ARGS__); \
-					}                                                                    \
-				BX_MACRO_BLOCK_END
-
-#define _BX_WARN(_condition, _format, ...)                        \
-				BX_MACRO_BLOCK_BEGIN                              \
-					if (!(_condition) )                           \
-					{                                             \
-						BX_TRACE("WARN " _format, ##__VA_ARGS__); \
-					}                                             \
-				BX_MACRO_BLOCK_END
-
-#define _BX_ASSERT(_condition, _format, ...)                       \
-				BX_MACRO_BLOCK_BEGIN                               \
-					if (!(_condition) )                            \
-					{                                              \
-						BX_TRACE("CHECK " _format, ##__VA_ARGS__); \
-						bx::debugBreak();                          \
-					}                                              \
-				BX_MACRO_BLOCK_END
-
-#define BX_TRACE  _BX_TRACE
-#define BX_WARN   _BX_WARN
-#define BX_ASSERT _BX_ASSERT
-
 #ifndef SHADERC_CONFIG_HLSL
 #	define SHADERC_CONFIG_HLSL BX_PLATFORM_WINDOWS
 #endif // SHADERC_CONFIG_HLSL

tools/shaderc/shaderc_glsl.cpp

@@ -330,23 +330,25 @@ namespace bgfx { namespace glsl
 			}
 		}
 
+		bx::Error err;
+
 		uint16_t count = (uint16_t)uniforms.size();
-		bx::write(_writer, count);
+		bx::write(_writer, 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);
-			bx::write(_writer, un.name.c_str(), nameSize);
+			bx::write(_writer, nameSize, &err);
+			bx::write(_writer, un.name.c_str(), nameSize, &err);
 			uint8_t uniformType = uint8_t(un.type);
-			bx::write(_writer, uniformType);
-			bx::write(_writer, un.num);
-			bx::write(_writer, un.regIndex);
-			bx::write(_writer, un.regCount);
-			bx::write(_writer, un.texComponent);
-			bx::write(_writer, un.texDimension);
-			bx::write(_writer, un.texFormat);
+			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_TRACE("%s, %s, %d, %d, %d"
 				, un.name.c_str()
@@ -358,10 +360,10 @@ namespace bgfx { namespace glsl
 		}
 
 		uint32_t shaderSize = (uint32_t)bx::strLen(optimizedShader);
-		bx::write(_writer, shaderSize);
-		bx::write(_writer, optimizedShader, shaderSize);
+		bx::write(_writer, shaderSize, &err);
+		bx::write(_writer, optimizedShader, shaderSize, &err);
 		uint8_t nul = 0;
-		bx::write(_writer, nul);
+		bx::write(_writer, nul, &err);
 
 		if (_options.disasm )
 		{

tools/shaderc/shaderc_metal.cpp

@@ -220,8 +220,10 @@ namespace bgfx { namespace metal
 	{
 		uint16_t size = 0;
 
+		bx::Error err;
+
 		uint16_t count = static_cast<uint16_t>(uniforms.size() );
-		bx::write(_writer, count);
+		bx::write(_writer, count, &err);
 
 		uint32_t fragmentBit = isFragmentShader ? kUniformFragmentBit : 0;
 		for (uint16_t ii = 0; ii < count; ++ii)
@@ -231,15 +233,15 @@ namespace bgfx { namespace metal
 			size += un.regCount*16;
 
 			uint8_t nameSize = (uint8_t)un.name.size();
-			bx::write(_writer, nameSize);
-			bx::write(_writer, un.name.c_str(), nameSize);
-			bx::write(_writer, uint8_t(un.type | fragmentBit) );
-			bx::write(_writer, un.num);
-			bx::write(_writer, un.regIndex);
-			bx::write(_writer, un.regCount);
-			bx::write(_writer, un.texComponent);
-			bx::write(_writer, un.texDimension);
-			bx::write(_writer, un.texFormat);
+			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_TRACE("%s, %s, %d, %d, %d"
 				, un.name.c_str()
@@ -540,6 +542,8 @@ namespace bgfx { namespace metal
 					}
 					uint16_t size = writeUniformArray( _writer, uniforms, _options.shaderType == 'f');
 
+					bx::Error err;
+
 					if (_version == BX_MAKEFOURCC('M', 'T', 'L', 0) )
 					{
 						spirv_cross::CompilerMSL msl(std::move(spirv) );
@@ -624,42 +628,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);
+								bx::write(_writer, dim, &err);
 							}
 						}
 
 						uint32_t shaderSize = (uint32_t)source.size();
-						bx::write(_writer, shaderSize);
-						bx::write(_writer, source.c_str(), shaderSize);
+						bx::write(_writer, shaderSize, &err);
+						bx::write(_writer, source.c_str(), shaderSize, &err);
 						uint8_t nul = 0;
-						bx::write(_writer, nul);
+						bx::write(_writer, nul, &err);
 					}
 					else
 					{
 						uint32_t shaderSize = (uint32_t)spirv.size() * sizeof(uint32_t);
-						bx::write(_writer, shaderSize);
-						bx::write(_writer, spirv.data(), shaderSize);
+						bx::write(_writer, shaderSize, &err);
+						bx::write(_writer, spirv.data(), shaderSize, &err);
 						uint8_t nul = 0;
-						bx::write(_writer, nul);
+						bx::write(_writer, nul, &err);
 					}
 					//
 					const uint8_t numAttr = (uint8_t)program->getNumLiveAttributes();
-					bx::write(_writer, numAttr);
+					bx::write(_writer, 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) );
+							bx::write(_writer, bgfx::attribToId(attr), &err);
 						}
 						else
 						{
-							bx::write(_writer, uint16_t(UINT16_MAX) );
+							bx::write(_writer, uint16_t(UINT16_MAX), &err);
 						}
 					}
 
-					bx::write(_writer, size);
+					bx::write(_writer, size, &err);
 				}
 			}
 		}

tools/shaderc/shaderc_spirv.cpp

@@ -326,8 +326,10 @@ namespace bgfx { namespace spirv
 	{
 		uint16_t size = 0;
 
+		bx::Error err;
+
 		uint16_t count = static_cast<uint16_t>(uniforms.size() );
-		bx::write(_writer, count);
+		bx::write(_writer, count, &err);
 
 		uint32_t fragmentBit = isFragmentShader ? kUniformFragmentBit : 0;
 
@@ -341,15 +343,15 @@ namespace bgfx { namespace spirv
 			}
 
 			uint8_t nameSize = (uint8_t)un.name.size();
-			bx::write(_writer, nameSize);
-			bx::write(_writer, un.name.c_str(), nameSize);
-			bx::write(_writer, uint8_t(un.type | fragmentBit) );
-			bx::write(_writer, un.num);
-			bx::write(_writer, un.regIndex);
-			bx::write(_writer, un.regCount);
-			bx::write(_writer, un.texComponent);
-			bx::write(_writer, un.texDimension);
-			bx::write(_writer, un.texFormat);
+			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_TRACE("%s, %s, %d, %d, %d"
 				, un.name.c_str()
@@ -801,6 +803,8 @@ namespace bgfx { namespace spirv
 						uniforms.push_back(un);
 					}
 
+					bx::Error err;
+
 					// Loop through the storage buffer, and extract the uniform names:
 					for (auto& resource : resourcesrefl.storage_buffers)
 					{
@@ -826,28 +830,28 @@ namespace bgfx { namespace spirv
 					uint16_t size = writeUniformArray( _writer, uniforms, _options.shaderType == 'f');
 
 					uint32_t shaderSize = (uint32_t)spirv.size() * sizeof(uint32_t);
-					bx::write(_writer, shaderSize);
-					bx::write(_writer, spirv.data(), shaderSize);
+					bx::write(_writer, shaderSize, &err);
+					bx::write(_writer, spirv.data(), shaderSize, &err);
 					uint8_t nul = 0;
-					bx::write(_writer, nul);
+					bx::write(_writer, nul, &err);
 
 					const uint8_t numAttr = (uint8_t)program->getNumLiveAttributes();
-					bx::write(_writer, numAttr);
+					bx::write(_writer, 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) );
+							bx::write(_writer, bgfx::attribToId(attr), &err);
 						}
 						else
 						{
-							bx::write(_writer, uint16_t(UINT16_MAX) );
+							bx::write(_writer, uint16_t(UINT16_MAX), &err);
 						}
 					}
 
-					bx::write(_writer, size);
+					bx::write(_writer, size, &err);
 				}
 			}
 		}

tools/texturev/texturev.cpp

@@ -800,7 +800,7 @@ struct View
 		bx::FileReader reader;
 		if (bx::open(&reader, filePath) )
 		{
-			bx::read(&reader, settings);
+			bx::read(&reader, settings, bx::ErrorAssert{});
 			bx::close(&reader);
 
 			if (!bx::fromString(&m_transitionTime, settings.get("view/transition") ) )
@@ -849,7 +849,7 @@ struct View
 			bx::FileWriter writer;
 			if (bx::open(&writer, filePath) )
 			{
-				bx::write(&writer, settings);
+				bx::write(&writer, settings, bx::ErrorAssert{});
 				bx::close(&writer);
 			}
 		}