scratchfoundation/bgfx
1
0
Fork 0
mirror of https://github.com/scratchfoundation/bgfx.git synced 2024-11-28 18:45:54 -05:00
Code Issues Projects Releases Packages Wiki Activity Actions

Removed using namespace bx.

Browse source
This commit is contained in:
bkaradzic 2013-08-03 22:15:13 -07:00
parent 44231e9c7f
commit e9504c9a26
7 changed files with 150 additions and 150 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

22
src/bgfx.cpp
View file

@ -573,7 +573,7 @@ namespace bgfx
if (BGFX_CONFIG_MAX_DRAW_CALLS-1 <= m_num if (BGFX_CONFIG_MAX_DRAW_CALLS-1 <= m_num
|| (0 == m_state.m_numVertices && 0 == m_state.m_numIndices) ) || (0 == m_state.m_numVertices && 0 == m_state.m_numIndices) )
{ {
m_numDropped += uint32_cntbits(_viewMask); m_numDropped += bx::uint32_cntbits(_viewMask);
return; return;
} }
@ -582,7 +582,7 @@ namespace bgfx
{ {
m_key.m_depth = _depth; m_key.m_depth = _depth;
for (uint32_t id = 0, viewMask = _viewMask, ntz = uint32_cnttz(_viewMask); 0 != viewMask; viewMask >>= 1, id += 1, ntz = uint32_cnttz(viewMask) ) for (uint32_t id = 0, viewMask = _viewMask, ntz = bx::uint32_cnttz(_viewMask); 0 != viewMask; viewMask >>= 1, id += 1, ntz = bx::uint32_cnttz(viewMask) )
{ {
viewMask >>= ntz; viewMask >>= ntz;
id += ntz; id += ntz;
@ -1059,10 +1059,10 @@ namespace bgfx
void calcTextureSize(TextureInfo& _info, uint16_t _width, uint16_t _height, uint16_t _depth, uint8_t _numMips, TextureFormat::Enum _format) void calcTextureSize(TextureInfo& _info, uint16_t _width, uint16_t _height, uint16_t _depth, uint8_t _numMips, TextureFormat::Enum _format)
{ {
_width = uint32_max(1, _width); _width = bx::uint32_max(1, _width);
_height = uint32_max(1, _height); _height = bx::uint32_max(1, _height);
_depth = uint32_max(1, _depth); _depth = bx::uint32_max(1, _depth);
_numMips = uint32_max(1, _numMips); _numMips = bx::uint32_max(1, _numMips);
uint32_t width = _width; uint32_t width = _width;
uint32_t height = _height; uint32_t height = _height;
@ -1073,9 +1073,9 @@ namespace bgfx
for (uint32_t lod = 0; lod < _numMips; ++lod) for (uint32_t lod = 0; lod < _numMips; ++lod)
{ {
width = uint32_max(1, width); width = bx::uint32_max(1, width);
height = uint32_max(1, height); height = bx::uint32_max(1, height);
depth = uint32_max(1, depth); depth = bx::uint32_max(1, depth);
size += _width*_height*depth*bpp/8; size += _width*_height*depth*bpp/8;
@ -1274,7 +1274,7 @@ namespace bgfx
{ {
BGFX_CHECK_MAIN_THREAD(); BGFX_CHECK_MAIN_THREAD();
BX_WARN(0 != _width && 0 != _height, "Render target resolution width or height cannot be 0 (width %d, height %d).", _width, _height); BX_WARN(0 != _width && 0 != _height, "Render target resolution width or height cannot be 0 (width %d, height %d).", _width, _height);
return s_ctx.createRenderTarget(uint16_max(1, _width), uint16_max(1, _height), _flags, _textureFlags); return s_ctx.createRenderTarget(bx::uint16_max(1, _width), bx::uint16_max(1, _height), _flags, _textureFlags);
} }
void destroyRenderTarget(RenderTargetHandle _handle) void destroyRenderTarget(RenderTargetHandle _handle)
@ -1437,7 +1437,7 @@ namespace bgfx
{ {
BGFX_CHECK_MAIN_THREAD(); BGFX_CHECK_MAIN_THREAD();
BX_CHECK(NULL != _tib, "_tib can't be NULL"); BX_CHECK(NULL != _tib, "_tib can't be NULL");
uint32_t numIndices = uint32_min(_numIndices, _tib->size/2); uint32_t numIndices = bx::uint32_min(_numIndices, _tib->size/2);
s_ctx.m_submit->setIndexBuffer(_tib, numIndices); s_ctx.m_submit->setIndexBuffer(_tib, numIndices);
} }

97
src/bgfx_p.h
View file

@ -54,7 +54,6 @@ namespace bgfx
} \ } \
} while(0) } while(0)
#define BX_NAMESPACE 1
#include <bx/bx.h> #include <bx/bx.h>
#include <bx/debug.h> #include <bx/debug.h>
#include <bx/blockalloc.h> #include <bx/blockalloc.h>
@ -184,14 +183,14 @@ namespace bgfx
void intersect(const Rect& _a, const Rect& _b) void intersect(const Rect& _a, const Rect& _b)
{ {
const uint16_t sx = uint16_max(_a.m_x, _b.m_x); const uint16_t sx = bx::uint16_max(_a.m_x, _b.m_x);
const uint16_t sy = uint16_max(_a.m_y, _b.m_y); const uint16_t sy = bx::uint16_max(_a.m_y, _b.m_y);
const uint16_t ex = uint16_min(_a.m_x + _a.m_width, _b.m_x + _b.m_width ); const uint16_t ex = bx::uint16_min(_a.m_x + _a.m_width, _b.m_x + _b.m_width );
const uint16_t ey = uint16_min(_a.m_y + _a.m_height, _b.m_y + _b.m_height); const uint16_t ey = bx::uint16_min(_a.m_y + _a.m_height, _b.m_y + _b.m_height);
m_x = sx; m_x = sx;
m_y = sy; m_y = sy;
m_width = (uint16_t)uint32_satsub(ex, sx); m_width = (uint16_t)bx::uint32_satsub(ex, sx);
m_height = (uint16_t)uint32_satsub(ey, sy); m_height = (uint16_t)bx::uint32_satsub(ey, sy);
} }
uint16_t m_x; uint16_t m_x;
@ -243,11 +242,11 @@ namespace bgfx
inline uint32_t strideAlign(uint32_t _offset, uint32_t _stride) inline uint32_t strideAlign(uint32_t _offset, uint32_t _stride)
{ {
const uint32_t mod = uint32_mod(_offset, _stride); const uint32_t mod = bx::uint32_mod(_offset, _stride);
const uint32_t add = uint32_sub(_stride, mod); const uint32_t add = bx::uint32_sub(_stride, mod);
const uint32_t mask = uint32_cmpeq(mod, 0); const uint32_t mask = bx::uint32_cmpeq(mod, 0);
const uint32_t tmp = uint32_selb(mask, 0, add); const uint32_t tmp = bx::uint32_selb(mask, 0, add);
const uint32_t result = uint32_add(_offset, tmp); const uint32_t result = bx::uint32_add(_offset, tmp);
return result; return result;
} }
@ -303,8 +302,8 @@ namespace bgfx
void resize(bool _small = false, uint16_t _width = BGFX_DEFAULT_WIDTH, uint16_t _height = BGFX_DEFAULT_HEIGHT) void resize(bool _small = false, uint16_t _width = BGFX_DEFAULT_WIDTH, uint16_t _height = BGFX_DEFAULT_HEIGHT)
{ {
uint32_t width = uint32_max(1, _width/8); uint32_t width = bx::uint32_max(1, _width/8);
uint32_t height = uint32_max(1, _height/(_small ? 8 : 16) ); uint32_t height = bx::uint32_max(1, _height/(_small ? 8 : 16) );
if (NULL == m_mem if (NULL == m_mem
|| m_width != width || m_width != width
@ -649,7 +648,7 @@ namespace bgfx
{ {
BX_CHECK(m_num+_num < BGFX_CONFIG_MAX_MATRIX_CACHE, "Matrix cache overflow. %d (max: %d)", m_num+_num, BGFX_CONFIG_MAX_MATRIX_CACHE); BX_CHECK(m_num+_num < BGFX_CONFIG_MAX_MATRIX_CACHE, "Matrix cache overflow. %d (max: %d)", m_num+_num, BGFX_CONFIG_MAX_MATRIX_CACHE);
uint32_t num = uint32_min(BGFX_CONFIG_MAX_MATRIX_CACHE-m_num, _num); uint32_t num = bx::uint32_min(BGFX_CONFIG_MAX_MATRIX_CACHE-m_num, _num);
uint32_t first = m_num; uint32_t first = m_num;
memcpy(&m_cache[m_num], _mtx, sizeof(Matrix4)*num); memcpy(&m_cache[m_num], _mtx, sizeof(Matrix4)*num);
m_num += num; m_num += num;
@ -723,7 +722,7 @@ namespace bgfx
public: public:
static ConstantBuffer* create(uint32_t _size) static ConstantBuffer* create(uint32_t _size)
{ {
uint32_t size = BX_ALIGN_16(uint32_max(_size, sizeof(ConstantBuffer) ) ); uint32_t size = BX_ALIGN_16(bx::uint32_max(_size, sizeof(ConstantBuffer) ) );
void* data = g_realloc(NULL, size); void* data = g_realloc(NULL, size);
return ::new(data) ConstantBuffer(_size); return ::new(data) ConstantBuffer(_size);
} }
@ -1103,7 +1102,7 @@ namespace bgfx
void setVertexBuffer(const DynamicVertexBuffer& _dvb, uint32_t _numVertices) void setVertexBuffer(const DynamicVertexBuffer& _dvb, uint32_t _numVertices)
{ {
m_state.m_startVertex = _dvb.m_startVertex; m_state.m_startVertex = _dvb.m_startVertex;
m_state.m_numVertices = uint32_min(_dvb.m_numVertices, _numVertices); m_state.m_numVertices = bx::uint32_min(_dvb.m_numVertices, _numVertices);
m_state.m_vertexBuffer = _dvb.m_handle; m_state.m_vertexBuffer = _dvb.m_handle;
m_state.m_vertexDecl = _dvb.m_decl; m_state.m_vertexDecl = _dvb.m_decl;
} }
@ -1111,7 +1110,7 @@ namespace bgfx
void setVertexBuffer(const TransientVertexBuffer* _tvb, uint32_t _numVertices) void setVertexBuffer(const TransientVertexBuffer* _tvb, uint32_t _numVertices)
{ {
m_state.m_startVertex = _tvb->startVertex; m_state.m_startVertex = _tvb->startVertex;
m_state.m_numVertices = uint32_min(_tvb->size/_tvb->stride, _numVertices); m_state.m_numVertices = bx::uint32_min(_tvb->size/_tvb->stride, _numVertices);
m_state.m_vertexBuffer = _tvb->handle; m_state.m_vertexBuffer = _tvb->handle;
m_state.m_vertexDecl = _tvb->decl; m_state.m_vertexDecl = _tvb->decl;
} }
@ -1120,7 +1119,7 @@ namespace bgfx
{ {
m_state.m_instanceDataOffset = _idb->offset; m_state.m_instanceDataOffset = _idb->offset;
m_state.m_instanceDataStride = _idb->stride; m_state.m_instanceDataStride = _idb->stride;
m_state.m_numInstances = uint16_min( (uint16_t)_idb->num, _num); m_state.m_numInstances = bx::uint16_min( (uint16_t)_idb->num, _num);
m_state.m_instanceDataBuffer = _idb->handle; m_state.m_instanceDataBuffer = _idb->handle;
g_free(const_cast<InstanceDataBuffer*>(_idb) ); g_free(const_cast<InstanceDataBuffer*>(_idb) );
} }
@ -1180,7 +1179,7 @@ namespace bgfx
{ {
uint32_t offset = m_iboffset; uint32_t offset = m_iboffset;
uint32_t iboffset = offset + _num*sizeof(uint16_t); uint32_t iboffset = offset + _num*sizeof(uint16_t);
iboffset = uint32_min(iboffset, BGFX_CONFIG_TRANSIENT_INDEX_BUFFER_SIZE); iboffset = bx::uint32_min(iboffset, BGFX_CONFIG_TRANSIENT_INDEX_BUFFER_SIZE);
uint32_t num = (iboffset-offset)/sizeof(uint16_t); uint32_t num = (iboffset-offset)/sizeof(uint16_t);
return num == _num; return num == _num;
} }
@ -1189,7 +1188,7 @@ namespace bgfx
{ {
uint32_t offset = m_iboffset; uint32_t offset = m_iboffset;
m_iboffset = offset + _num*sizeof(uint16_t); m_iboffset = offset + _num*sizeof(uint16_t);
m_iboffset = uint32_min(m_iboffset, BGFX_CONFIG_TRANSIENT_INDEX_BUFFER_SIZE); m_iboffset = bx::uint32_min(m_iboffset, BGFX_CONFIG_TRANSIENT_INDEX_BUFFER_SIZE);
_num = (m_iboffset-offset)/sizeof(uint16_t); _num = (m_iboffset-offset)/sizeof(uint16_t);
return offset; return offset;
} }
@ -1198,7 +1197,7 @@ namespace bgfx
{ {
uint32_t offset = strideAlign(m_vboffset, _stride); uint32_t offset = strideAlign(m_vboffset, _stride);
uint32_t vboffset = offset + _num * _stride; uint32_t vboffset = offset + _num * _stride;
vboffset = uint32_min(vboffset, BGFX_CONFIG_TRANSIENT_VERTEX_BUFFER_SIZE); vboffset = bx::uint32_min(vboffset, BGFX_CONFIG_TRANSIENT_VERTEX_BUFFER_SIZE);
uint32_t num = (vboffset-offset)/_stride; uint32_t num = (vboffset-offset)/_stride;
return num == _num; return num == _num;
} }
@ -1207,7 +1206,7 @@ namespace bgfx
{ {
uint32_t offset = strideAlign(m_vboffset, _stride); uint32_t offset = strideAlign(m_vboffset, _stride);
m_vboffset = offset + _num * _stride; m_vboffset = offset + _num * _stride;
m_vboffset = uint32_min(m_vboffset, BGFX_CONFIG_TRANSIENT_VERTEX_BUFFER_SIZE); m_vboffset = bx::uint32_min(m_vboffset, BGFX_CONFIG_TRANSIENT_VERTEX_BUFFER_SIZE);
_num = (m_vboffset-offset)/_stride; _num = (m_vboffset-offset)/_stride;
return offset; return offset;
} }
@ -1360,7 +1359,7 @@ namespace bgfx
memset(m_vertexBufferRef, 0xff, sizeof(m_vertexBufferRef) ); memset(m_vertexBufferRef, 0xff, sizeof(m_vertexBufferRef) );
} }
void shutdown(HandleAlloc& _handleAlloc) void shutdown(bx::HandleAlloc& _handleAlloc)
{ {
for (VertexDeclMap::iterator it = m_vertexDeclMap.begin(), itEnd = m_vertexDeclMap.end(); it != itEnd; ++it) for (VertexDeclMap::iterator it = m_vertexDeclMap.begin(), itEnd = m_vertexDeclMap.end(); it != itEnd; ++it)
{ {
@ -1588,8 +1587,8 @@ namespace bgfx
void reset(uint32_t _width, uint32_t _height, uint32_t _flags) void reset(uint32_t _width, uint32_t _height, uint32_t _flags)
{ {
BX_WARN(0 != _width && 0 != _height, "Frame buffer resolution width or height cannot be 0 (width %d, height %d).", _width, _height); BX_WARN(0 != _width && 0 != _height, "Frame buffer resolution width or height cannot be 0 (width %d, height %d).", _width, _height);
m_resolution.m_width = uint32_max(1, _width); m_resolution.m_width = bx::uint32_max(1, _width);
m_resolution.m_height = uint32_max(1, _height); m_resolution.m_height = bx::uint32_max(1, _height);
m_resolution.m_flags = _flags; m_resolution.m_flags = _flags;
memset(m_rt, 0xff, sizeof(m_rt) ); memset(m_rt, 0xff, sizeof(m_rt) );
@ -2261,7 +2260,7 @@ namespace bgfx
{ {
Uniform& uniform = m_uniform[_handle.idx]; Uniform& uniform = m_uniform[_handle.idx];
BX_CHECK(uniform.m_num >= _num, "Truncated uniform update. %d (max: %d)", _num, uniform.m_num); BX_CHECK(uniform.m_num >= _num, "Truncated uniform update. %d (max: %d)", _num, uniform.m_num);
m_submit->writeConstant(uniform.m_type, _handle, _value, uint16_min(uniform.m_num, _num) ); m_submit->writeConstant(uniform.m_type, _handle, _value, bx::uint16_min(uniform.m_num, _num) );
} }
void setViewName(uint8_t _id, const char* _name) void setViewName(uint8_t _id, const char* _name)
@ -2278,13 +2277,13 @@ namespace bgfx
Rect& rect = m_rect[_id]; Rect& rect = m_rect[_id];
rect.m_x = _x; rect.m_x = _x;
rect.m_y = _y; rect.m_y = _y;
rect.m_width = uint16_max(_width, 1); rect.m_width = bx::uint16_max(_width, 1);
rect.m_height = uint16_max(_height, 1); rect.m_height = bx::uint16_max(_height, 1);
} }
void setViewRectMask(uint32_t _viewMask, uint16_t _x, uint16_t _y, uint16_t _width, uint16_t _height) void setViewRectMask(uint32_t _viewMask, uint16_t _x, uint16_t _y, uint16_t _width, uint16_t _height)
{ {
for (uint32_t view = 0, viewMask = _viewMask, ntz = uint32_cnttz(_viewMask); 0 != viewMask; viewMask >>= 1, view += 1, ntz = uint32_cnttz(viewMask) ) for (uint32_t view = 0, viewMask = _viewMask, ntz = bx::uint32_cnttz(_viewMask); 0 != viewMask; viewMask >>= 1, view += 1, ntz = bx::uint32_cnttz(viewMask) )
{ {
viewMask >>= ntz; viewMask >>= ntz;
view += ntz; view += ntz;
@ -2304,7 +2303,7 @@ namespace bgfx
void setViewScissorMask(uint32_t _viewMask, uint16_t _x, uint16_t _y, uint16_t _width, uint16_t _height) void setViewScissorMask(uint32_t _viewMask, uint16_t _x, uint16_t _y, uint16_t _width, uint16_t _height)
{ {
for (uint32_t view = 0, viewMask = _viewMask, ntz = uint32_cnttz(_viewMask); 0 != viewMask; viewMask >>= 1, view += 1, ntz = uint32_cnttz(viewMask) ) for (uint32_t view = 0, viewMask = _viewMask, ntz = bx::uint32_cnttz(_viewMask); 0 != viewMask; viewMask >>= 1, view += 1, ntz = bx::uint32_cnttz(viewMask) )
{ {
viewMask >>= ntz; viewMask >>= ntz;
view += ntz; view += ntz;
@ -2324,7 +2323,7 @@ namespace bgfx
void setViewClearMask(uint32_t _viewMask, uint8_t _flags, uint32_t _rgba, float _depth, uint8_t _stencil) void setViewClearMask(uint32_t _viewMask, uint8_t _flags, uint32_t _rgba, float _depth, uint8_t _stencil)
{ {
for (uint32_t view = 0, viewMask = _viewMask, ntz = uint32_cnttz(_viewMask); 0 != viewMask; viewMask >>= 1, view += 1, ntz = uint32_cnttz(viewMask) ) for (uint32_t view = 0, viewMask = _viewMask, ntz = bx::uint32_cnttz(_viewMask); 0 != viewMask; viewMask >>= 1, view += 1, ntz = bx::uint32_cnttz(viewMask) )
{ {
viewMask >>= ntz; viewMask >>= ntz;
view += ntz; view += ntz;
@ -2341,7 +2340,7 @@ namespace bgfx
void setViewSeqMask(uint32_t _viewMask, bool _enabled) void setViewSeqMask(uint32_t _viewMask, bool _enabled)
{ {
uint16_t mask = _enabled ? 0xffff : 0x0; uint16_t mask = _enabled ? 0xffff : 0x0;
for (uint32_t view = 0, viewMask = _viewMask, ntz = uint32_cnttz(_viewMask); 0 != viewMask; viewMask >>= 1, view += 1, ntz = uint32_cnttz(viewMask) ) for (uint32_t view = 0, viewMask = _viewMask, ntz = bx::uint32_cnttz(_viewMask); 0 != viewMask; viewMask >>= 1, view += 1, ntz = bx::uint32_cnttz(viewMask) )
{ {
viewMask >>= ntz; viewMask >>= ntz;
view += ntz; view += ntz;
@ -2357,7 +2356,7 @@ namespace bgfx
void setViewRenderTargetMask(uint32_t _viewMask, RenderTargetHandle _handle) void setViewRenderTargetMask(uint32_t _viewMask, RenderTargetHandle _handle)
{ {
for (uint32_t view = 0, viewMask = _viewMask, ntz = uint32_cnttz(_viewMask); 0 != viewMask; viewMask >>= 1, view += 1, ntz = uint32_cnttz(viewMask) ) for (uint32_t view = 0, viewMask = _viewMask, ntz = bx::uint32_cnttz(_viewMask); 0 != viewMask; viewMask >>= 1, view += 1, ntz = bx::uint32_cnttz(viewMask) )
{ {
viewMask >>= ntz; viewMask >>= ntz;
view += ntz; view += ntz;
@ -2398,7 +2397,7 @@ namespace bgfx
void setViewTransformMask(uint32_t _viewMask, const void* _view, const void* _proj, uint8_t _other) void setViewTransformMask(uint32_t _viewMask, const void* _view, const void* _proj, uint8_t _other)
{ {
for (uint32_t view = 0, viewMask = _viewMask, ntz = uint32_cnttz(_viewMask); 0 != viewMask; viewMask >>= 1, view += 1, ntz = uint32_cnttz(viewMask) ) for (uint32_t view = 0, viewMask = _viewMask, ntz = bx::uint32_cnttz(_viewMask); 0 != viewMask; viewMask >>= 1, view += 1, ntz = bx::uint32_cnttz(viewMask) )
{ {
viewMask >>= ntz; viewMask >>= ntz;
view += ntz; view += ntz;
@ -3098,8 +3097,8 @@ namespace bgfx
m_submit->m_waitRender = bx::getHPCounter() - start; m_submit->m_waitRender = bx::getHPCounter() - start;
} }
Semaphore m_renderSem; bx::Semaphore m_renderSem;
Semaphore m_gameSem; bx::Semaphore m_gameSem;
#else #else
void gameSemPost() void gameSemPost()
{ {
@ -3118,7 +3117,7 @@ namespace bgfx
} }
#endif // BGFX_CONFIG_MULTITHREADED #endif // BGFX_CONFIG_MULTITHREADED
Thread m_thread; bx::Thread m_thread;
Frame m_frame[2]; Frame m_frame[2];
Frame* m_render; Frame* m_render;
Frame* m_submit; Frame* m_submit;
@ -3135,19 +3134,19 @@ namespace bgfx
DynamicVertexBufferHandle m_freeDynamicVertexBufferHandle[BGFX_CONFIG_MAX_DYNAMIC_VERTEX_BUFFERS]; DynamicVertexBufferHandle m_freeDynamicVertexBufferHandle[BGFX_CONFIG_MAX_DYNAMIC_VERTEX_BUFFERS];
NonLocalAllocator m_dynamicIndexBufferAllocator; NonLocalAllocator m_dynamicIndexBufferAllocator;
HandleAlloc m_dynamicIndexBufferHandle; bx::HandleAlloc m_dynamicIndexBufferHandle;
NonLocalAllocator m_dynamicVertexBufferAllocator; NonLocalAllocator m_dynamicVertexBufferAllocator;
HandleAlloc m_dynamicVertexBufferHandle; bx::HandleAlloc m_dynamicVertexBufferHandle;
HandleAlloc m_indexBufferHandle; bx::HandleAlloc m_indexBufferHandle;
HandleAlloc m_vertexDeclHandle; bx::HandleAlloc m_vertexDeclHandle;
HandleAlloc m_vertexBufferHandle; bx::HandleAlloc m_vertexBufferHandle;
HandleAlloc m_vertexShaderHandle; bx::HandleAlloc m_vertexShaderHandle;
HandleAlloc m_fragmentShaderHandle; bx::HandleAlloc m_fragmentShaderHandle;
HandleAlloc m_programHandle; bx::HandleAlloc m_programHandle;
HandleAlloc m_textureHandle; bx::HandleAlloc m_textureHandle;
HandleAlloc m_renderTargetHandle; bx::HandleAlloc m_renderTargetHandle;
HandleAlloc m_uniformHandle; bx::HandleAlloc m_uniformHandle;
struct VertexShaderRef struct VertexShaderRef
{ {

11
src/dds.cpp
View file

@ -75,6 +75,7 @@ bool isDds(const Memory* _mem)
uint32_t bitRangeConvert(uint32_t _in, uint32_t _from, uint32_t _to) uint32_t bitRangeConvert(uint32_t _in, uint32_t _from, uint32_t _to)
{ {
using namespace bx;
uint32_t tmp0 = uint32_sll(1, _to); uint32_t tmp0 = uint32_sll(1, _to);
uint32_t tmp1 = uint32_sll(1, _from); uint32_t tmp1 = uint32_sll(1, _from);
uint32_t tmp2 = uint32_dec(tmp0); uint32_t tmp2 = uint32_dec(tmp0);
@ -575,15 +576,15 @@ bool getRawImageData(const Dds& _dds, uint8_t _side, uint8_t _lod, const Memory*
for (uint8_t lod = 0, num = _dds.m_numMips; lod < num; ++lod) for (uint8_t lod = 0, num = _dds.m_numMips; lod < num; ++lod)
{ {
width = uint32_max(1, width); width = bx::uint32_max(1, width);
height = uint32_max(1, height); height = bx::uint32_max(1, height);
depth = uint32_max(1, depth); depth = bx::uint32_max(1, depth);
uint32_t size = width*height*depth*blockSize; uint32_t size = width*height*depth*blockSize;
if (TextureFormat::Unknown > type) if (TextureFormat::Unknown > type)
{ {
width = uint32_max(1, (width + 3)>>2); width = bx::uint32_max(1, (width + 3)>>2);
height = uint32_max(1, (height + 3)>>2); height = bx::uint32_max(1, (height + 3)>>2);
size = width*height*depth*blockSize; size = width*height*depth*blockSize;
width <<= 2; width <<= 2;

50
src/renderer_d3d11.cpp
View file

@ -851,7 +851,7 @@ namespace bgfx
uint32_t ref = (fstencil&BGFX_STENCIL_FUNC_REF_MASK)>>BGFX_STENCIL_FUNC_REF_SHIFT; uint32_t ref = (fstencil&BGFX_STENCIL_FUNC_REF_MASK)>>BGFX_STENCIL_FUNC_REF_SHIFT;
_stencil &= packStencil(~BGFX_STENCIL_FUNC_REF_MASK, BGFX_STENCIL_MASK); _stencil &= packStencil(~BGFX_STENCIL_FUNC_REF_MASK, BGFX_STENCIL_MASK);
HashMurmur2A murmur; bx::HashMurmur2A murmur;
murmur.begin(); murmur.begin();
murmur.add(_state); murmur.add(_state);
murmur.add(_stencil); murmur.add(_stencil);
@ -1617,7 +1617,7 @@ namespace bgfx
} }
else else
{ {
m_hash = hashMurmur2A(code, shaderSize); m_hash = bx::hashMurmur2A(code, shaderSize);
m_code = alloc(shaderSize); m_code = alloc(shaderSize);
memcpy(m_code->data, code, shaderSize); memcpy(m_code->data, code, shaderSize);
@ -1665,15 +1665,15 @@ namespace bgfx
for (uint8_t side = 0, numSides = dds.m_cubeMap ? 6 : 1; side < numSides; ++side) for (uint8_t side = 0, numSides = dds.m_cubeMap ? 6 : 1; side < numSides; ++side)
{ {
uint32_t width = dds.m_width; uint32_t width = dds.m_width;
uint32_t height = dds.m_height; uint32_t height = dds.m_height;
uint32_t depth = dds.m_depth; uint32_t depth = dds.m_depth;
for (uint32_t lod = 0, num = m_numMips; lod < num; ++lod) for (uint32_t lod = 0, num = m_numMips; lod < num; ++lod)
{ {
width = uint32_max(1, width); width = bx::uint32_max(1, width);
height = uint32_max(1, height); height = bx::uint32_max(1, height);
depth = uint32_max(1, depth); depth = bx::uint32_max(1, depth);
Mip mip; Mip mip;
if (getRawImageData(dds, side, lod, _mem, mip) ) if (getRawImageData(dds, side, lod, _mem, mip) )
@ -1696,9 +1696,9 @@ namespace bgfx
++kk; ++kk;
} }
width >>= 1; width >>= 1;
height >>= 1; height >>= 1;
depth >>= 1; depth >>= 1;
} }
} }
} }
@ -1859,15 +1859,15 @@ namespace bgfx
for (uint8_t side = 0, numSides = tc.m_cubeMap ? 6 : 1; side < numSides; ++side) for (uint8_t side = 0, numSides = tc.m_cubeMap ? 6 : 1; side < numSides; ++side)
{ {
uint32_t width = tc.m_width; uint32_t width = tc.m_width;
uint32_t height = tc.m_height; uint32_t height = tc.m_height;
uint32_t depth = tc.m_depth; uint32_t depth = tc.m_depth;
for (uint32_t lod = 0, num = tc.m_numMips; lod < num; ++lod) for (uint32_t lod = 0, num = tc.m_numMips; lod < num; ++lod)
{ {
width = uint32_max(1, width); width = bx::uint32_max(1, width);
height = uint32_max(1, height); height = bx::uint32_max(1, height);
depth = uint32_max(1, depth); depth = bx::uint32_max(1, depth);
srd[lod].pSysMem = data; srd[lod].pSysMem = data;
srd[lod].SysMemPitch = width*bpp/8; srd[lod].SysMemPitch = width*bpp/8;
@ -1875,9 +1875,9 @@ namespace bgfx
data += width*height*bpp/8; data += width*height*bpp/8;
width >>= 1; width >>= 1;
height >>= 1; height >>= 1;
depth >>= 1; depth >>= 1;
} }
} }
@ -2154,7 +2154,7 @@ namespace bgfx
void Context::rendererUpdateDynamicIndexBuffer(IndexBufferHandle _handle, uint32_t _offset, uint32_t _size, Memory* _mem) void Context::rendererUpdateDynamicIndexBuffer(IndexBufferHandle _handle, uint32_t _offset, uint32_t _size, Memory* _mem)
{ {
s_renderCtx.m_indexBuffers[_handle.idx].update(_offset, uint32_min(_size, _mem->size), _mem->data); s_renderCtx.m_indexBuffers[_handle.idx].update(_offset, bx::uint32_min(_size, _mem->size), _mem->data);
} }
void Context::rendererDestroyDynamicIndexBuffer(IndexBufferHandle _handle) void Context::rendererDestroyDynamicIndexBuffer(IndexBufferHandle _handle)
@ -2170,7 +2170,7 @@ namespace bgfx
void Context::rendererUpdateDynamicVertexBuffer(VertexBufferHandle _handle, uint32_t _offset, uint32_t _size, Memory* _mem) void Context::rendererUpdateDynamicVertexBuffer(VertexBufferHandle _handle, uint32_t _offset, uint32_t _size, Memory* _mem)
{ {
s_renderCtx.m_vertexBuffers[_handle.idx].update(_offset, uint32_min(_size, _mem->size), _mem->data); s_renderCtx.m_vertexBuffers[_handle.idx].update(_offset, bx::uint32_min(_size, _mem->size), _mem->data);
} }
void Context::rendererDestroyDynamicVertexBuffer(VertexBufferHandle _handle) void Context::rendererDestroyDynamicVertexBuffer(VertexBufferHandle _handle)
@ -2548,20 +2548,20 @@ namespace bgfx
case PredefinedUniform::View: case PredefinedUniform::View:
{ {
s_renderCtx.setShaderConstant(flags, predefined.m_loc, m_render->m_view[view].val, uint32_min(4, predefined.m_count) ); s_renderCtx.setShaderConstant(flags, predefined.m_loc, m_render->m_view[view].val, bx::uint32_min(4, predefined.m_count) );
} }
break; break;
case PredefinedUniform::ViewProj: case PredefinedUniform::ViewProj:
{ {
s_renderCtx.setShaderConstant(flags, predefined.m_loc, viewProj[view].val, uint32_min(4, predefined.m_count) ); s_renderCtx.setShaderConstant(flags, predefined.m_loc, viewProj[view].val, bx::uint32_min(4, predefined.m_count) );
} }
break; break;
case PredefinedUniform::Model: case PredefinedUniform::Model:
{ {
const Matrix4& model = m_render->m_matrixCache.m_cache[state.m_matrix]; const Matrix4& model = m_render->m_matrixCache.m_cache[state.m_matrix];
s_renderCtx.setShaderConstant(flags, predefined.m_loc, model.val, uint32_min(state.m_num*4, predefined.m_count) ); s_renderCtx.setShaderConstant(flags, predefined.m_loc, model.val, bx::uint32_min(state.m_num*4, predefined.m_count) );
} }
break; break;
@ -2570,7 +2570,7 @@ namespace bgfx
Matrix4 modelView; Matrix4 modelView;
const Matrix4& model = m_render->m_matrixCache.m_cache[state.m_matrix]; const Matrix4& model = m_render->m_matrixCache.m_cache[state.m_matrix];
mtxMul(modelView.val, model.val, m_render->m_view[view].val); mtxMul(modelView.val, model.val, m_render->m_view[view].val);
s_renderCtx.setShaderConstant(flags, predefined.m_loc, modelView.val, uint32_min(4, predefined.m_count) ); s_renderCtx.setShaderConstant(flags, predefined.m_loc, modelView.val, bx::uint32_min(4, predefined.m_count) );
} }
break; break;
@ -2579,7 +2579,7 @@ namespace bgfx
Matrix4 modelViewProj; Matrix4 modelViewProj;
const Matrix4& model = m_render->m_matrixCache.m_cache[state.m_matrix]; const Matrix4& model = m_render->m_matrixCache.m_cache[state.m_matrix];
mtxMul(modelViewProj.val, model.val, viewProj[view].val); mtxMul(modelViewProj.val, model.val, viewProj[view].val);
s_renderCtx.setShaderConstant(flags, predefined.m_loc, modelViewProj.val, uint32_min(4, predefined.m_count) ); s_renderCtx.setShaderConstant(flags, predefined.m_loc, modelViewProj.val, bx::uint32_min(4, predefined.m_count) );
} }
break; break;
@ -2602,7 +2602,7 @@ namespace bgfx
Matrix4 modelViewProj; Matrix4 modelViewProj;
mtxMul(modelViewProj.val, model.val, viewProjBias.val); mtxMul(modelViewProj.val, model.val, viewProjBias.val);
s_renderCtx.setShaderConstant(flags, predefined.m_loc, modelViewProj.val, uint32_min(4, predefined.m_count) ); s_renderCtx.setShaderConstant(flags, predefined.m_loc, modelViewProj.val, bx::uint32_min(4, predefined.m_count) );
} }
break; break;
@ -2620,7 +2620,7 @@ namespace bgfx
Matrix4 viewProjBias; Matrix4 viewProjBias;
mtxMul(viewProjBias.val, viewProj[other].val, s_bias); mtxMul(viewProjBias.val, viewProj[other].val, s_bias);
s_renderCtx.setShaderConstant(flags, predefined.m_loc, viewProjBias.val, uint32_min(4, predefined.m_count) ); s_renderCtx.setShaderConstant(flags, predefined.m_loc, viewProjBias.val, bx::uint32_min(4, predefined.m_count) );
} }
break; break;

62
src/renderer_d3d9.cpp
View file

@ -548,7 +548,7 @@ namespace bgfx
if (SUCCEEDED(hr) ) if (SUCCEEDED(hr) )
{ {
s_msaa[ii].m_type = msaa; s_msaa[ii].m_type = msaa;
s_msaa[ii].m_quality = uint32_imax(0, quality-1); s_msaa[ii].m_quality = bx::uint32_imax(0, quality-1);
last = ii; last = ii;
} }
else else
@ -1537,15 +1537,15 @@ namespace bgfx
{ {
for (uint8_t side = 0, numSides = dds.m_cubeMap ? 6 : 1; side < numSides; ++side) for (uint8_t side = 0, numSides = dds.m_cubeMap ? 6 : 1; side < numSides; ++side)
{ {
uint32_t width = dds.m_width; uint32_t width = dds.m_width;
uint32_t height = dds.m_height; uint32_t height = dds.m_height;
uint32_t depth = dds.m_depth; uint32_t depth = dds.m_depth;
for (uint32_t lod = 0, num = dds.m_numMips; lod < num; ++lod) for (uint32_t lod = 0, num = dds.m_numMips; lod < num; ++lod)
{ {
width = uint32_max(1, width); width = bx::uint32_max(1, width);
height = uint32_max(1, height); height = bx::uint32_max(1, height);
depth = uint32_max(1, depth); depth = bx::uint32_max(1, depth);
Mip mip; Mip mip;
if (getRawImageData(dds, side, lod, _mem, mip) ) if (getRawImageData(dds, side, lod, _mem, mip) )
@ -1580,9 +1580,9 @@ namespace bgfx
unlock(side, lod); unlock(side, lod);
} }
width >>= 1; width >>= 1;
height >>= 1; height >>= 1;
depth >>= 1; depth >>= 1;
} }
} }
} }
@ -1598,15 +1598,15 @@ namespace bgfx
for (uint8_t side = 0, numSides = dds.m_cubeMap ? 6 : 1; side < numSides; ++side) for (uint8_t side = 0, numSides = dds.m_cubeMap ? 6 : 1; side < numSides; ++side)
{ {
uint32_t width = dds.m_width; uint32_t width = dds.m_width;
uint32_t height = dds.m_height; uint32_t height = dds.m_height;
uint32_t depth = dds.m_depth; uint32_t depth = dds.m_depth;
for (uint32_t lod = 0, num = dds.m_numMips; lod < num; ++lod) for (uint32_t lod = 0, num = dds.m_numMips; lod < num; ++lod)
{ {
width = uint32_max(1, width); width = bx::uint32_max(1, width);
height = uint32_max(1, height); height = bx::uint32_max(1, height);
depth = uint32_max(1, depth); depth = bx::uint32_max(1, depth);
Mip mip; Mip mip;
if (getRawImageData(dds, 0, lod, _mem, mip) ) if (getRawImageData(dds, 0, lod, _mem, mip) )
@ -1622,9 +1622,9 @@ namespace bgfx
unlock(side, lod); unlock(side, lod);
} }
width >>= 1; width >>= 1;
height >>= 1; height >>= 1;
depth >>= 1; depth >>= 1;
} }
} }
} }
@ -1662,15 +1662,15 @@ namespace bgfx
for (uint8_t side = 0, numSides = tc.m_cubeMap ? 6 : 1; side < numSides; ++side) for (uint8_t side = 0, numSides = tc.m_cubeMap ? 6 : 1; side < numSides; ++side)
{ {
uint32_t width = tc.m_width; uint32_t width = tc.m_width;
uint32_t height = tc.m_height; uint32_t height = tc.m_height;
uint32_t depth = tc.m_depth; uint32_t depth = tc.m_depth;
for (uint32_t lod = 0, num = tc.m_numMips; lod < num; ++lod) for (uint32_t lod = 0, num = tc.m_numMips; lod < num; ++lod)
{ {
width = uint32_max(1, width); width = bx::uint32_max(1, width);
height = uint32_max(1, height); height = bx::uint32_max(1, height);
depth = uint32_max(1, depth); depth = bx::uint32_max(1, depth);
uint32_t pitch; uint32_t pitch;
uint32_t slicePitch; uint32_t slicePitch;
@ -1680,9 +1680,9 @@ namespace bgfx
data += len; data += len;
unlock(side, lod); unlock(side, lod);
width >>= 1; width >>= 1;
height >>= 1; height >>= 1;
depth >>= 1; depth >>= 1;
} }
} }
@ -2084,7 +2084,7 @@ namespace bgfx
void Context::rendererUpdateDynamicIndexBuffer(IndexBufferHandle _handle, uint32_t _offset, uint32_t _size, Memory* _mem) void Context::rendererUpdateDynamicIndexBuffer(IndexBufferHandle _handle, uint32_t _offset, uint32_t _size, Memory* _mem)
{ {
s_renderCtx.m_indexBuffers[_handle.idx].update(_offset, uint32_min(_size, _mem->size), _mem->data); s_renderCtx.m_indexBuffers[_handle.idx].update(_offset, bx::uint32_min(_size, _mem->size), _mem->data);
} }
void Context::rendererDestroyDynamicIndexBuffer(IndexBufferHandle _handle) void Context::rendererDestroyDynamicIndexBuffer(IndexBufferHandle _handle)
@ -2100,7 +2100,7 @@ namespace bgfx
void Context::rendererUpdateDynamicVertexBuffer(VertexBufferHandle _handle, uint32_t _offset, uint32_t _size, Memory* _mem) void Context::rendererUpdateDynamicVertexBuffer(VertexBufferHandle _handle, uint32_t _offset, uint32_t _size, Memory* _mem)
{ {
s_renderCtx.m_vertexBuffers[_handle.idx].update(_offset, uint32_min(_size, _mem->size), _mem->data); s_renderCtx.m_vertexBuffers[_handle.idx].update(_offset, bx::uint32_min(_size, _mem->size), _mem->data);
} }
void Context::rendererDestroyDynamicVertexBuffer(VertexBufferHandle _handle) void Context::rendererDestroyDynamicVertexBuffer(VertexBufferHandle _handle)
@ -2612,20 +2612,20 @@ namespace bgfx
case PredefinedUniform::View: case PredefinedUniform::View:
{ {
s_renderCtx.setShaderConstantF(flags, predefined.m_loc, m_render->m_view[view].val, uint32_min(4, predefined.m_count) ); s_renderCtx.setShaderConstantF(flags, predefined.m_loc, m_render->m_view[view].val, bx::uint32_min(4, predefined.m_count) );
} }
break; break;
case PredefinedUniform::ViewProj: case PredefinedUniform::ViewProj:
{ {
s_renderCtx.setShaderConstantF(flags, predefined.m_loc, viewProj[view].val, uint32_min(4, predefined.m_count) ); s_renderCtx.setShaderConstantF(flags, predefined.m_loc, viewProj[view].val, bx::uint32_min(4, predefined.m_count) );
} }
break; break;
case PredefinedUniform::Model: case PredefinedUniform::Model:
{ {
const Matrix4& model = m_render->m_matrixCache.m_cache[state.m_matrix]; const Matrix4& model = m_render->m_matrixCache.m_cache[state.m_matrix];
s_renderCtx.setShaderConstantF(flags, predefined.m_loc, model.val, uint32_min(state.m_num*4, predefined.m_count) ); s_renderCtx.setShaderConstantF(flags, predefined.m_loc, model.val, bx::uint32_min(state.m_num*4, predefined.m_count) );
} }
break; break;
@ -2634,7 +2634,7 @@ namespace bgfx
Matrix4 modelView; Matrix4 modelView;
const Matrix4& model = m_render->m_matrixCache.m_cache[state.m_matrix]; const Matrix4& model = m_render->m_matrixCache.m_cache[state.m_matrix];
mtxMul(modelView.val, model.val, m_render->m_view[view].val); mtxMul(modelView.val, model.val, m_render->m_view[view].val);
s_renderCtx.setShaderConstantF(flags, predefined.m_loc, modelView.val, uint32_min(4, predefined.m_count) ); s_renderCtx.setShaderConstantF(flags, predefined.m_loc, modelView.val, bx::uint32_min(4, predefined.m_count) );
} }
break; break;
@ -2643,7 +2643,7 @@ namespace bgfx
Matrix4 modelViewProj; Matrix4 modelViewProj;
const Matrix4& model = m_render->m_matrixCache.m_cache[state.m_matrix]; const Matrix4& model = m_render->m_matrixCache.m_cache[state.m_matrix];
mtxMul(modelViewProj.val, model.val, viewProj[view].val); mtxMul(modelViewProj.val, model.val, viewProj[view].val);
s_renderCtx.setShaderConstantF(flags, predefined.m_loc, modelViewProj.val, uint32_min(4, predefined.m_count) ); s_renderCtx.setShaderConstantF(flags, predefined.m_loc, modelViewProj.val, bx::uint32_min(4, predefined.m_count) );
} }
break; break;
@ -2666,7 +2666,7 @@ namespace bgfx
Matrix4 modelViewProj; Matrix4 modelViewProj;
mtxMul(modelViewProj.val, model.val, viewProjBias.val); mtxMul(modelViewProj.val, model.val, viewProjBias.val);
s_renderCtx.setShaderConstantF(flags, predefined.m_loc, modelViewProj.val, uint32_min(4, predefined.m_count) ); s_renderCtx.setShaderConstantF(flags, predefined.m_loc, modelViewProj.val, bx::uint32_min(4, predefined.m_count) );
} }
break; break;
@ -2684,7 +2684,7 @@ namespace bgfx
Matrix4 viewProjBias; Matrix4 viewProjBias;
mtxMul(viewProjBias.val, viewProj[other].val, s_bias); mtxMul(viewProjBias.val, viewProj[other].val, s_bias);
s_renderCtx.setShaderConstantF(flags, predefined.m_loc, viewProjBias.val, uint32_min(4, predefined.m_count) ); s_renderCtx.setShaderConstantF(flags, predefined.m_loc, viewProjBias.val, bx::uint32_min(4, predefined.m_count) );
} }
break; break;

56
src/renderer_gl.cpp
View file

@ -429,11 +429,11 @@ namespace bgfx
const char* space = strchr(pos, ' '); const char* space = strchr(pos, ' ');
if (NULL != space) if (NULL != space)
{ {
len = uint32_min(sizeof(name), (uint32_t)(space - pos) ); len = bx::uint32_min(sizeof(name), (uint32_t)(space - pos) );
} }
else else
{ {
len = uint32_min(sizeof(name), (uint32_t)strlen(pos) ); len = bx::uint32_min(sizeof(name), (uint32_t)strlen(pos) );
} }
strncpy(name, pos, len); strncpy(name, pos, len);
@ -521,7 +521,7 @@ namespace bgfx
m_resolution = _resolution; m_resolution = _resolution;
uint32_t msaa = 1<<( (m_resolution.m_flags&BGFX_RESET_MSAA_MASK)>>BGFX_RESET_MSAA_SHIFT); uint32_t msaa = 1<<( (m_resolution.m_flags&BGFX_RESET_MSAA_MASK)>>BGFX_RESET_MSAA_SHIFT);
msaa = uint32_min(m_maxMsaa, msaa == 0 ? 0 : 1<<msaa); msaa = bx::uint32_min(m_maxMsaa, msaa == 0 ? 0 : 1<<msaa);
bool vsync = !!(m_resolution.m_flags&BGFX_RESET_VSYNC); bool vsync = !!(m_resolution.m_flags&BGFX_RESET_VSYNC);
setRenderContextSize(_resolution.m_width, _resolution.m_height, msaa, vsync); setRenderContextSize(_resolution.m_width, _resolution.m_height, msaa, vsync);
updateCapture(); updateCapture();
@ -1109,7 +1109,7 @@ namespace bgfx
GL_CHECK(glGetProgramiv(m_id, GL_ACTIVE_ATTRIBUTE_MAX_LENGTH, &max0) ); GL_CHECK(glGetProgramiv(m_id, GL_ACTIVE_ATTRIBUTE_MAX_LENGTH, &max0) );
GL_CHECK(glGetProgramiv(m_id, GL_ACTIVE_UNIFORM_MAX_LENGTH, &max1) ); GL_CHECK(glGetProgramiv(m_id, GL_ACTIVE_UNIFORM_MAX_LENGTH, &max1) );
GLint maxLength = uint32_max(max0, max1); GLint maxLength = bx::uint32_max(max0, max1);
char* name = (char*)g_realloc(NULL, maxLength + 1); char* name = (char*)g_realloc(NULL, maxLength + 1);
BX_TRACE("Program %d", m_id); BX_TRACE("Program %d", m_id);
@ -1461,9 +1461,9 @@ namespace bgfx
for (uint32_t lod = 0, num = numMips; lod < num; ++lod) for (uint32_t lod = 0, num = numMips; lod < num; ++lod)
{ {
width = uint32_max(1, width); width = bx::uint32_max(1, width);
height = uint32_max(1, height); height = bx::uint32_max(1, height);
depth = uint32_max(1, depth); depth = bx::uint32_max(1, depth);
Mip mip; Mip mip;
if (getRawImageData(dds, side, lod, _mem, mip) ) if (getRawImageData(dds, side, lod, _mem, mip) )
@ -1502,15 +1502,15 @@ namespace bgfx
for (uint8_t side = 0, numSides = dds.m_cubeMap ? 6 : 1; side < numSides; ++side) for (uint8_t side = 0, numSides = dds.m_cubeMap ? 6 : 1; side < numSides; ++side)
{ {
uint32_t width = dds.m_width; uint32_t width = dds.m_width;
uint32_t height = dds.m_height; uint32_t height = dds.m_height;
uint32_t depth = dds.m_depth; uint32_t depth = dds.m_depth;
for (uint32_t ii = 0, num = numMips; ii < num; ++ii) for (uint32_t ii = 0, num = numMips; ii < num; ++ii)
{ {
width = uint32_max(1, width); width = bx::uint32_max(1, width);
height = uint32_max(1, height); height = bx::uint32_max(1, height);
depth = uint32_max(1, depth); depth = bx::uint32_max(1, depth);
Mip mip; Mip mip;
if (getRawImageData(dds, side, ii, _mem, mip) ) if (getRawImageData(dds, side, ii, _mem, mip) )
@ -1527,9 +1527,9 @@ namespace bgfx
); );
} }
width >>= 1; width >>= 1;
height >>= 1; height >>= 1;
depth >>= 1; depth >>= 1;
} }
} }
} }
@ -1592,15 +1592,15 @@ namespace bgfx
for (uint8_t side = 0, numSides = tc.m_cubeMap ? 6 : 1; side < numSides; ++side) for (uint8_t side = 0, numSides = tc.m_cubeMap ? 6 : 1; side < numSides; ++side)
{ {
uint32_t width = tc.m_width; uint32_t width = tc.m_width;
uint32_t height = tc.m_height; uint32_t height = tc.m_height;
uint32_t depth = tc.m_depth; uint32_t depth = tc.m_depth;
for (uint32_t lod = 0, num = numMips; lod < num; ++lod) for (uint32_t lod = 0, num = numMips; lod < num; ++lod)
{ {
width = uint32_max(width, min); width = bx::uint32_max(width, min);
height = uint32_max(height, min); height = bx::uint32_max(height, min);
depth = uint32_max(1, depth); depth = bx::uint32_max(1, depth);
uint32_t size = width*height*bpp/8; uint32_t size = width*height*bpp/8;
if (m_compressed) if (m_compressed)
@ -1642,9 +1642,9 @@ namespace bgfx
data += size; data += size;
} }
width >>= 1; width >>= 1;
height >>= 1; height >>= 1;
depth >>= 1; depth >>= 1;
} }
} }
@ -1917,7 +1917,7 @@ namespace bgfx
m_width = _width; m_width = _width;
m_height = _height; m_height = _height;
uint32_t msaa = (_flags&BGFX_RENDER_TARGET_MSAA_MASK)>>BGFX_RENDER_TARGET_MSAA_SHIFT; uint32_t msaa = (_flags&BGFX_RENDER_TARGET_MSAA_MASK)>>BGFX_RENDER_TARGET_MSAA_SHIFT;
m_msaa = uint32_min(s_renderCtx.m_maxMsaa, msaa == 0 ? 0 : 1<<msaa); m_msaa = bx::uint32_min(s_renderCtx.m_maxMsaa, msaa == 0 ? 0 : 1<<msaa);
uint32_t colorFormat = (_flags&BGFX_RENDER_TARGET_COLOR_MASK)>>BGFX_RENDER_TARGET_COLOR_SHIFT; uint32_t colorFormat = (_flags&BGFX_RENDER_TARGET_COLOR_MASK)>>BGFX_RENDER_TARGET_COLOR_SHIFT;
uint32_t depthFormat = (_flags&BGFX_RENDER_TARGET_DEPTH_MASK)>>BGFX_RENDER_TARGET_DEPTH_SHIFT; uint32_t depthFormat = (_flags&BGFX_RENDER_TARGET_DEPTH_MASK)>>BGFX_RENDER_TARGET_DEPTH_SHIFT;
@ -2426,11 +2426,11 @@ namespace bgfx
const char* space = strchr(pos, ' '); const char* space = strchr(pos, ' ');
if (NULL != space) if (NULL != space)
{ {
len = uint32_min(sizeof(name), (uint32_t)(space - pos) ); len = bx::uint32_min(sizeof(name), (uint32_t)(space - pos) );
} }
else else
{ {
len = uint32_min(sizeof(name), (uint32_t)strlen(pos) ); len = bx::uint32_min(sizeof(name), (uint32_t)strlen(pos) );
} }
strncpy(name, pos, len); strncpy(name, pos, len);
@ -2640,7 +2640,7 @@ namespace bgfx
void Context::rendererUpdateDynamicIndexBuffer(IndexBufferHandle _handle, uint32_t _offset, uint32_t _size, Memory* _mem) void Context::rendererUpdateDynamicIndexBuffer(IndexBufferHandle _handle, uint32_t _offset, uint32_t _size, Memory* _mem)
{ {
s_renderCtx.m_indexBuffers[_handle.idx].update(_offset, uint32_min(_size, _mem->size), _mem->data); s_renderCtx.m_indexBuffers[_handle.idx].update(_offset, bx::uint32_min(_size, _mem->size), _mem->data);
} }
void Context::rendererDestroyDynamicIndexBuffer(IndexBufferHandle _handle) void Context::rendererDestroyDynamicIndexBuffer(IndexBufferHandle _handle)
@ -2656,7 +2656,7 @@ namespace bgfx
void Context::rendererUpdateDynamicVertexBuffer(VertexBufferHandle _handle, uint32_t _offset, uint32_t _size, Memory* _mem) void Context::rendererUpdateDynamicVertexBuffer(VertexBufferHandle _handle, uint32_t _offset, uint32_t _size, Memory* _mem)
{ {
s_renderCtx.m_vertexBuffers[_handle.idx].update(_offset, uint32_min(_size, _mem->size), _mem->data); s_renderCtx.m_vertexBuffers[_handle.idx].update(_offset, bx::uint32_min(_size, _mem->size), _mem->data);
} }
void Context::rendererDestroyDynamicVertexBuffer(VertexBufferHandle _handle) void Context::rendererDestroyDynamicVertexBuffer(VertexBufferHandle _handle)
@ -3017,7 +3017,7 @@ namespace bgfx
#if BGFX_CONFIG_RENDERER_OPENGL #if BGFX_CONFIG_RENDERER_OPENGL
if ( (BGFX_STATE_PT_POINTS|BGFX_STATE_POINT_SIZE_MASK) & changedFlags) if ( (BGFX_STATE_PT_POINTS|BGFX_STATE_POINT_SIZE_MASK) & changedFlags)
{ {
float pointSize = (float)(uint32_max(1, (newFlags&BGFX_STATE_POINT_SIZE_MASK)>>BGFX_STATE_POINT_SIZE_SHIFT) ); float pointSize = (float)(bx::uint32_max(1, (newFlags&BGFX_STATE_POINT_SIZE_MASK)>>BGFX_STATE_POINT_SIZE_SHIFT) );
GL_CHECK(glPointSize(pointSize) ); GL_CHECK(glPointSize(pointSize) );
} }
@ -3158,7 +3158,7 @@ namespace bgfx
{ {
const Matrix4& model = m_render->m_matrixCache.m_cache[state.m_matrix]; const Matrix4& model = m_render->m_matrixCache.m_cache[state.m_matrix];
GL_CHECK(glUniformMatrix4fv(predefined.m_loc GL_CHECK(glUniformMatrix4fv(predefined.m_loc
, uint32_min(predefined.m_count, state.m_num) , bx::uint32_min(predefined.m_count, state.m_num)
, GL_FALSE , GL_FALSE
, model.val , model.val
) ); ) );

2
src/renderer_gl.h
View file

@ -547,7 +547,7 @@ namespace bgfx
m_type = _type; m_type = _type;
bx::MemoryReader reader(_mem->data, _mem->size); bx::MemoryReader reader(_mem->data, _mem->size);
m_hash = hashMurmur2A(_mem->data, _mem->size); m_hash = bx::hashMurmur2A(_mem->data, _mem->size);
uint32_t magic; uint32_t magic;
bx::read(&reader, magic); bx::read(&reader, magic);