diff --git a/examples/13-stencil/stencil.cpp b/examples/13-stencil/stencil.cpp index 3e01b5e8b..beb6d0cfd 100644 --- a/examples/13-stencil/stencil.cpp +++ b/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(material.c_str() ), len); + bx::read(reader, const_cast(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(name.c_str() ), len); + bx::read(reader, const_cast(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); } diff --git a/examples/14-shadowvolumes/shadowvolumes.cpp b/examples/14-shadowvolumes/shadowvolumes.cpp index 3a5b2f23e..115b2b521 100644 --- a/examples/14-shadowvolumes/shadowvolumes.cpp +++ b/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); } } diff --git a/examples/16-shadowmaps/shadowmaps.cpp b/examples/16-shadowmaps/shadowmaps.cpp index 11c648c78..e4e28d8ff 100644 --- a/examples/16-shadowmaps/shadowmaps.cpp +++ b/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 diff --git a/examples/42-bunnylod/bunnylod.cpp b/examples/42-bunnylod/bunnylod.cpp index a3738095c..3324ac039 100644 --- a/examples/42-bunnylod/bunnylod.cpp +++ b/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); } } diff --git a/examples/45-bokeh/bokeh.cpp b/examples/45-bokeh/bokeh.cpp index 7a53d359b..307a39d8b 100644 --- a/examples/45-bokeh/bokeh.cpp +++ b/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; diff --git a/examples/common/aviwriter.h b/examples/common/aviwriter.h index 34d3fbf21..a6bd392d8 100644 --- a/examples/common/aviwriter.h +++ b/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_t(0), &err); // 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, 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') ); - bx::write(m_writer, UINT32_C(116) ); - bx::write(m_writer, BX_MAKEFOURCC('s', 't', 'r', 'l') ); + 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, 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') ); + 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); } } diff --git a/examples/common/bgfx_utils.cpp b/examples/common/bgfx_utils.cpp index 6573b8828..01f1d2ee4 100644 --- a/examples/common/bgfx_utils.cpp +++ b/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(material.c_str() ), len); + read(_reader, const_cast(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(name.c_str() ), len); + read(_reader, const_cast(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); } diff --git a/examples/common/debugdraw/debugdraw.cpp b/examples/common/debugdraw/debugdraw.cpp index d2c806712..5bdb1e7bd 100644 --- a/examples/common/debugdraw/debugdraw.cpp +++ b/examples/common/debugdraw/debugdraw.cpp @@ -9,6 +9,7 @@ #include "../bgfx_utils.h" #include "../packrect.h" +#include #include #include #include @@ -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); diff --git a/examples/common/entry/entry_sdl.cpp b/examples/common/entry/entry_sdl.cpp index 360d1df0a..059894590 100644 --- a/examples/common/entry/entry_sdl.cpp +++ b/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'; diff --git a/examples/common/font/font_manager.cpp b/examples/common/font/font_manager.cpp index 71c298ce7..5259eafba 100644 --- a/examples/common/font/font_manager.cpp +++ b/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; } diff --git a/examples/common/font/text_buffer_manager.cpp b/examples/common/font/text_buffer_manager.cpp index 131fecf3a..096d44345 100644 --- a/examples/common/font/text_buffer_manager.cpp +++ b/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(); } diff --git a/examples/common/ps/particle_system.cpp b/examples/common/ps/particle_system.cpp index 53146597a..6d9bfeff9 100644 --- a/examples/common/ps/particle_system.cpp +++ b/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 ); diff --git a/scripts/bgfx.lua b/scripts/bgfx.lua index 7f176a2e2..3fbc912b8 100644 --- a/scripts/bgfx.lua +++ b/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"), diff --git a/scripts/example-common.lua b/scripts/example-common.lua index 6a1101a3e..62787d183 100644 --- a/scripts/example-common.lua +++ b/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 {} diff --git a/scripts/genie.lua b/scripts/genie.lua index 410f6baf0..fe34647f7 100644 --- a/scripts/genie.lua +++ b/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 diff --git a/scripts/geometryc.lua b/scripts/geometryc.lua index d17b83268..84dcb2a11 100644 --- a/scripts/geometryc.lua +++ b/scripts/geometryc.lua @@ -23,9 +23,7 @@ project "geometryc" path.join(BGFX_DIR, "examples/common/bounds.**"), } - links { - "bx", - } + using_bx(); configuration { "mingw-*" } targetextension ".exe" diff --git a/scripts/geometryv.lua b/scripts/geometryv.lua index 9707ee7a4..4c0bda2f4 100644 --- a/scripts/geometryv.lua +++ b/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" } diff --git a/scripts/shaderc.lua b/scripts/shaderc.lua index 3900dc0f4..75841ccfa 100644 --- a/scripts/shaderc.lua +++ b/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"), diff --git a/scripts/texturec.lua b/scripts/texturec.lua index 304ab7e7c..577b5c62c 100644 --- a/scripts/texturec.lua +++ b/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 { diff --git a/scripts/texturev.lua b/scripts/texturev.lua index bbbdd9ca4..772546e05 100644 --- a/scripts/texturev.lua +++ b/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" } diff --git a/src/bgfx.cpp b/src/bgfx.cpp index 7df640e1d..d5bbef73f 100644 --- a/src/bgfx.cpp +++ b/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(_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); } diff --git a/src/bgfx_p.h b/src/bgfx_p.h index c1f70ec82..62fe83366 100644 --- a/src/bgfx_p.h +++ b/src/bgfx_p.h @@ -8,16 +8,19 @@ #include -#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 #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 #include #include @@ -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() ) { diff --git a/src/config.h b/src/config.h index 1566b321c..be901d4c4 100644 --- a/src/config.h +++ b/src/config.h @@ -6,7 +6,7 @@ #ifndef BGFX_CONFIG_H_HEADER_GUARD #define BGFX_CONFIG_H_HEADER_GUARD -#include +#include // 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) \ diff --git a/src/renderer_gl.cpp b/src/renderer_gl.cpp index c8088abe1..713afc28c 100644 --- a/src/renderer_gl.cpp +++ b/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(_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; } diff --git a/src/renderer_vk.cpp b/src/renderer_vk.cpp index f13fc8957..43792ff09 100644 --- a/src/renderer_vk.cpp +++ b/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; diff --git a/src/shader.cpp b/src/shader.cpp index 8f7473749..6254fa676 100644 --- a/src/shader.cpp +++ b/src/shader.cpp @@ -121,8 +121,10 @@ namespace bgfx bx::WriterI* writer = reinterpret_cast(_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(_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(_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; diff --git a/src/shader_dxbc.cpp b/src/shader_dxbc.cpp index b442257bc..3c0b2b216 100644 --- a/src/shader_dxbc.cpp +++ b/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); diff --git a/tools/geometryc/geometryc.cpp b/tools/geometryc/geometryc.cpp index 8139681ad..3a5748791 100644 --- a/tools/geometryc/geometryc.cpp +++ b/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]; diff --git a/tools/geometryv/geometryv.cpp b/tools/geometryv/geometryv.cpp index 25d044244..40929126e 100644 --- a/tools/geometryv/geometryv.cpp +++ b/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); } } diff --git a/tools/shaderc/shaderc.cpp b/tools/shaderc/shaderc.cpp index 7932dec02..1562b49c5 100644 --- a/tools/shaderc/shaderc.cpp +++ b/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' diff --git a/tools/shaderc/shaderc.h b/tools/shaderc/shaderc.h index 46672548f..18afd15d8 100644 --- a/tools/shaderc/shaderc.h +++ b/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 diff --git a/tools/shaderc/shaderc_glsl.cpp b/tools/shaderc/shaderc_glsl.cpp index ea27f2345..6a9a26f5e 100644 --- a/tools/shaderc/shaderc_glsl.cpp +++ b/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 ) { diff --git a/tools/shaderc/shaderc_metal.cpp b/tools/shaderc/shaderc_metal.cpp index 120600c09..d66b5544a 100644 --- a/tools/shaderc/shaderc_metal.cpp +++ b/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(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); } } } diff --git a/tools/shaderc/shaderc_spirv.cpp b/tools/shaderc/shaderc_spirv.cpp index 3e77b49b4..a60d69d82 100644 --- a/tools/shaderc/shaderc_spirv.cpp +++ b/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(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); } } } diff --git a/tools/texturev/texturev.cpp b/tools/texturev/texturev.cpp index 1d7c28064..c4043273e 100644 --- a/tools/texturev/texturev.cpp +++ b/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); } }