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

Fixed assert macros, and improved error handling.

Browse Source
This commit is contained in:
Бранимир Караџић
2021-10-25 18:59:32 -07:00
parent 6573fc44a8
commit 8392a44b3a
35 changed files with 705 additions and 617 deletions
Download Patch File Download Diff File Expand all files Collapse all files

46
examples/13-stencil/stencil.cpp
View File

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

1
examples/14-shadowvolumes/shadowvolumes.cpp
View File

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

2
examples/16-shadowmaps/shadowmaps.cpp
View File

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

27
examples/42-bunnylod/bunnylod.cpp
View File

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

15
examples/45-bokeh/bokeh.cpp
View File

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

151
examples/common/aviwriter.h
View File

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

69
examples/common/bgfx_utils.cpp
View File

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

34
examples/common/debugdraw/debugdraw.cpp
View File

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

2
examples/common/entry/entry_sdl.cpp
View File

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

23
examples/common/font/font_manager.cpp
View File

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

47
examples/common/font/text_buffer_manager.cpp
View File

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

6
examples/common/ps/particle_system.cpp
View File

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

11
scripts/bgfx.lua
View File

@@ -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"),

10
scripts/example-common.lua
View File

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

12
scripts/genie.lua
View File

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

4
scripts/geometryc.lua
View File

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

4
scripts/geometryv.lua
View File

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

4
scripts/shaderc.lua
View File

@@ -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"),

4
scripts/texturec.lua
View File

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

4
scripts/texturev.lua
View File

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

107
src/bgfx.cpp
View File

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

62
src/bgfx_p.h
View File

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

8
src/config.h
View File

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

177
src/renderer_gl.cpp
View File

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

56
src/renderer_vk.cpp
View File

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

28
src/shader.cpp
View File

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

14
src/shader_dxbc.cpp
View File

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

147
tools/geometryc/geometryc.cpp
View File

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

6
tools/geometryv/geometryv.cpp
View File

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

96
tools/shaderc/shaderc.cpp
View File

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

29
tools/shaderc/shaderc.h
View File

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

28
tools/shaderc/shaderc_glsl.cpp
View File

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

46
tools/shaderc/shaderc_metal.cpp
View File

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

38
tools/shaderc/shaderc_spirv.cpp
View File

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

4
tools/texturev/texturev.cpp
View File

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