diff options
Diffstat (limited to '3rdparty/bgfx/src')
30 files changed, 2558 insertions, 1335 deletions
diff --git a/3rdparty/bgfx/src/amalgamated.cpp b/3rdparty/bgfx/src/amalgamated.cpp index d98dd37ddab..d61f06845cd 100644 --- a/3rdparty/bgfx/src/amalgamated.cpp +++ b/3rdparty/bgfx/src/amalgamated.cpp @@ -20,4 +20,5 @@ #include "shader_dxbc.cpp" #include "shader_dx9bc.cpp" #include "shader_spirv.cpp" +#include "topology.cpp" #include "vertexdecl.cpp" diff --git a/3rdparty/bgfx/src/bgfx.cpp b/3rdparty/bgfx/src/bgfx.cpp index e16d4f71c3f..0e9a558903c 100644 --- a/3rdparty/bgfx/src/bgfx.cpp +++ b/3rdparty/bgfx/src/bgfx.cpp @@ -18,6 +18,9 @@ # include <remotery/lib/Remotery.c> #endif // BGFX_CONFIG_PROFILER_REMOTERY_BUILD_LIB +#include <bx/crtimpl.h> +#include "topology.h" + namespace bgfx { #define BGFX_MAIN_THREAD_MAGIC UINT32_C(0x78666762) @@ -700,7 +703,8 @@ namespace bgfx } } else if (RendererType::OpenGLES == g_caps.rendererType - || RendererType::OpenGL == g_caps.rendererType) + || RendererType::OpenGL == g_caps.rendererType + || RendererType::Vulkan == g_caps.rendererType) { vsh = createShader(makeRef(vs_clear_glsl, sizeof(vs_clear_glsl) ) ); @@ -844,7 +848,7 @@ namespace bgfx return PredefinedUniform::Count; } - uint32_t Frame::submit(uint8_t _id, ProgramHandle _program, OcclusionQueryHandle _occlusionQuery, int32_t _depth) + uint32_t Frame::submit(uint8_t _id, ProgramHandle _program, OcclusionQueryHandle _occlusionQuery, int32_t _depth, bool _preserveState) { if (m_discard) { @@ -891,9 +895,12 @@ namespace bgfx m_renderItem[m_numRenderItems].draw = m_draw; ++m_numRenderItems; - m_draw.clear(); - m_uniformBegin = m_uniformEnd; - m_stateFlags = BGFX_STATE_NONE; + if (!_preserveState) + { + m_draw.clear(); + m_uniformBegin = m_uniformEnd; + m_stateFlags = BGFX_STATE_NONE; + } return m_num; } @@ -981,13 +988,13 @@ namespace bgfx { m_sortKeys[ii] = SortKey::remapView(m_sortKeys[ii], m_viewRemap); } - bx::radixSort64(m_sortKeys, s_ctx->m_tempKeys, m_sortValues, s_ctx->m_tempValues, m_num); + bx::radixSort(m_sortKeys, s_ctx->m_tempKeys, m_sortValues, s_ctx->m_tempValues, m_num); for (uint32_t ii = 0, num = m_num; ii < num; ++ii) { m_blitKeys[ii] = BlitKey::remapView(m_blitKeys[ii], m_viewRemap); } - bx::radixSort32(m_blitKeys, (uint32_t*)&s_ctx->m_tempKeys, m_numBlitItems); + bx::radixSort(m_blitKeys, (uint32_t*)&s_ctx->m_tempKeys, m_numBlitItems); } RenderFrame::Enum renderFrame() @@ -1145,6 +1152,38 @@ namespace bgfx BX_TRACE("Max FB attachments: %d", g_caps.maxFBAttachments); } + TextureFormat::Enum getViableTextureFormat(const ImageContainer& _imageContainer) + { + const uint32_t formatCaps = g_caps.formats[_imageContainer.m_format]; + bool convert = 0 == formatCaps; + + if (_imageContainer.m_cubeMap) + { + convert |= 0 == (formatCaps & BGFX_CAPS_FORMAT_TEXTURE_CUBE) + && 0 != (formatCaps & BGFX_CAPS_FORMAT_TEXTURE_CUBE_EMULATED) + ; + } + else if (_imageContainer.m_depth > 1) + { + convert |= 0 == (formatCaps & BGFX_CAPS_FORMAT_TEXTURE_3D) + && 0 != (formatCaps & BGFX_CAPS_FORMAT_TEXTURE_3D_EMULATED) + ; + } + else + { + convert |= 0 == (formatCaps & BGFX_CAPS_FORMAT_TEXTURE_2D) + && 0 != (formatCaps & BGFX_CAPS_FORMAT_TEXTURE_2D_EMULATED) + ; + } + + if (convert) + { + return TextureFormat::BGRA8; + } + + return _imageContainer.m_format; + } + static TextureFormat::Enum s_emulatedFormats[] = { TextureFormat::BC1, @@ -1244,20 +1283,17 @@ namespace bgfx for (uint32_t ii = 0; ii < BX_COUNTOF(s_emulatedFormats); ++ii) { const uint32_t fmt = s_emulatedFormats[ii]; - if (0 == (g_caps.formats[fmt] & BGFX_CAPS_FORMAT_TEXTURE_2D) ) - { - g_caps.formats[fmt] |= BGFX_CAPS_FORMAT_TEXTURE_2D_EMULATED; - } - - if (0 == (g_caps.formats[fmt] & BGFX_CAPS_FORMAT_TEXTURE_3D) ) - { - g_caps.formats[fmt] |= BGFX_CAPS_FORMAT_TEXTURE_3D_EMULATED; - } + g_caps.formats[fmt] |= 0 == (g_caps.formats[fmt] & BGFX_CAPS_FORMAT_TEXTURE_2D ) ? BGFX_CAPS_FORMAT_TEXTURE_2D_EMULATED : 0; + g_caps.formats[fmt] |= 0 == (g_caps.formats[fmt] & BGFX_CAPS_FORMAT_TEXTURE_3D ) ? BGFX_CAPS_FORMAT_TEXTURE_3D_EMULATED : 0; + g_caps.formats[fmt] |= 0 == (g_caps.formats[fmt] & BGFX_CAPS_FORMAT_TEXTURE_CUBE) ? BGFX_CAPS_FORMAT_TEXTURE_CUBE_EMULATED : 0; + } - if (0 == (g_caps.formats[fmt] & BGFX_CAPS_FORMAT_TEXTURE_CUBE) ) - { - g_caps.formats[fmt] |= BGFX_CAPS_FORMAT_TEXTURE_CUBE_EMULATED; - } + for (uint32_t ii = 0; ii < TextureFormat::Count; ++ii) + { + bool convertable = imageConvert(TextureFormat::BGRA8, TextureFormat::Enum(ii) ); + g_caps.formats[ii] |= 0 == (g_caps.formats[ii] & BGFX_CAPS_FORMAT_TEXTURE_2D ) && convertable ? BGFX_CAPS_FORMAT_TEXTURE_2D_EMULATED : 0; + g_caps.formats[ii] |= 0 == (g_caps.formats[ii] & BGFX_CAPS_FORMAT_TEXTURE_3D ) && convertable ? BGFX_CAPS_FORMAT_TEXTURE_3D_EMULATED : 0; + g_caps.formats[ii] |= 0 == (g_caps.formats[ii] & BGFX_CAPS_FORMAT_TEXTURE_CUBE) && convertable ? BGFX_CAPS_FORMAT_TEXTURE_CUBE_EMULATED : 0; } g_caps.rendererType = m_renderCtx->getRendererType(); @@ -1721,6 +1757,8 @@ namespace bgfx RendererContextI* rendererCreate(RendererType::Enum _type) { + RendererType::Enum last = RendererType::Count; + if (RendererType::Count == _type) { again: @@ -1793,7 +1831,7 @@ again: { _type = RendererType::OpenGLES; } - else if (BX_ENABLED(BX_PLATFORM_WINRT) ) + else if (BX_ENABLED(BX_PLATFORM_XBOXONE || BX_PLATFORM_WINRT) ) { _type = RendererType::Direct3D11; } @@ -1823,14 +1861,17 @@ again: } RendererContextI* renderCtx = s_rendererCreator[_type].createFn(); - - if (NULL == renderCtx) + if (last != _type) { - s_rendererCreator[_type].supported = false; - goto again; - } + if (NULL == renderCtx) + { + s_rendererCreator[_type].supported = false; + last = _type; + goto again; + } - s_rendererDestroyFn = s_rendererCreator[_type].destroyFn; + s_rendererDestroyFn = s_rendererCreator[_type].destroyFn; + } return renderCtx; } @@ -2339,6 +2380,11 @@ again: flushTextureUpdateBatch(_cmdbuf); } + uint32_t topologyConvert(TopologyConvert::Enum _conversion, void* _dst, uint32_t _dstSize, const void* _indices, uint32_t _numIndices, bool _index32) + { + return topologyConvert(_conversion, _dst, _dstSize, _indices, _numIndices, _index32, g_allocator); + } + uint8_t getSupportedRenderers(RendererType::Enum _enum[RendererType::Count]) { uint8_t num = 0; @@ -3359,12 +3405,22 @@ again: s_ctx->setUniform(_handle, _value, _num); } + void setIndexBuffer(IndexBufferHandle _handle) + { + setIndexBuffer(_handle, 0, UINT32_MAX); + } + void setIndexBuffer(IndexBufferHandle _handle, uint32_t _firstIndex, uint32_t _numIndices) { BGFX_CHECK_MAIN_THREAD(); s_ctx->setIndexBuffer(_handle, _firstIndex, _numIndices); } + void setIndexBuffer(DynamicIndexBufferHandle _handle) + { + setIndexBuffer(_handle, 0, UINT32_MAX); + } + void setIndexBuffer(DynamicIndexBufferHandle _handle, uint32_t _firstIndex, uint32_t _numIndices) { BGFX_CHECK_MAIN_THREAD(); @@ -3395,10 +3451,15 @@ again: s_ctx->setVertexBuffer(_handle, _startVertex, _numVertices); } - void setVertexBuffer(DynamicVertexBufferHandle _handle, uint32_t _numVertices) + void setVertexBuffer(DynamicVertexBufferHandle _handle) + { + setVertexBuffer(_handle, 0, UINT32_MAX); + } + + void setVertexBuffer(DynamicVertexBufferHandle _handle, uint32_t _startVertex, uint32_t _numVertices) { BGFX_CHECK_MAIN_THREAD(); - s_ctx->setVertexBuffer(_handle, _numVertices); + s_ctx->setVertexBuffer(_handle, _startVertex, _numVertices); } void setVertexBuffer(const TransientVertexBuffer* _tvb) @@ -3450,13 +3511,13 @@ again: return submit(_id, handle); } - uint32_t submit(uint8_t _id, ProgramHandle _program, int32_t _depth) + uint32_t submit(uint8_t _id, ProgramHandle _program, int32_t _depth, bool _preserveState) { OcclusionQueryHandle handle = BGFX_INVALID_HANDLE; - return submit(_id, _program, handle, _depth); + return submit(_id, _program, handle, _depth, _preserveState); } - uint32_t submit(uint8_t _id, ProgramHandle _program, OcclusionQueryHandle _occlusionQuery, int32_t _depth) + uint32_t submit(uint8_t _id, ProgramHandle _program, OcclusionQueryHandle _occlusionQuery, int32_t _depth, bool _preserveState) { BGFX_CHECK_MAIN_THREAD(); BX_CHECK(false @@ -3464,13 +3525,13 @@ again: || 0 != (g_caps.supported & BGFX_CAPS_OCCLUSION_QUERY) , "Occlusion query is not supported! Use bgfx::getCaps to check BGFX_CAPS_OCCLUSION_QUERY backend renderer capabilities." ); - return s_ctx->submit(_id, _program, _occlusionQuery, _depth); + return s_ctx->submit(_id, _program, _occlusionQuery, _depth, _preserveState); } - uint32_t submit(uint8_t _id, ProgramHandle _program, IndirectBufferHandle _indirectHandle, uint16_t _start, uint16_t _num, int32_t _depth) + uint32_t submit(uint8_t _id, ProgramHandle _program, IndirectBufferHandle _indirectHandle, uint16_t _start, uint16_t _num, int32_t _depth, bool _preserveState) { BGFX_CHECK_MAIN_THREAD(); - return s_ctx->submit(_id, _program, _indirectHandle, _start, _num, _depth); + return s_ctx->submit(_id, _program, _indirectHandle, _start, _num, _depth, _preserveState); } void setBuffer(uint8_t _stage, IndexBufferHandle _handle, Access::Enum _access) @@ -3593,23 +3654,34 @@ BX_STATIC_ASSERT(FLAGS_MASK_TEST(0 #undef FLAGS_MASK_TEST -BX_STATIC_ASSERT(bgfx::Fatal::Count == bgfx::Fatal::Enum(BGFX_FATAL_COUNT) ); -BX_STATIC_ASSERT(bgfx::RendererType::Count == bgfx::RendererType::Enum(BGFX_RENDERER_TYPE_COUNT) ); -BX_STATIC_ASSERT(bgfx::Attrib::Count == bgfx::Attrib::Enum(BGFX_ATTRIB_COUNT) ); -BX_STATIC_ASSERT(bgfx::AttribType::Count == bgfx::AttribType::Enum(BGFX_ATTRIB_TYPE_COUNT) ); -BX_STATIC_ASSERT(bgfx::TextureFormat::Count == bgfx::TextureFormat::Enum(BGFX_TEXTURE_FORMAT_COUNT) ); -BX_STATIC_ASSERT(bgfx::UniformType::Count == bgfx::UniformType::Enum(BGFX_UNIFORM_TYPE_COUNT) ); -BX_STATIC_ASSERT(bgfx::RenderFrame::Count == bgfx::RenderFrame::Enum(BGFX_RENDER_FRAME_COUNT) ); - -BX_STATIC_ASSERT(sizeof(bgfx::Memory) == sizeof(bgfx_memory_t) ); -BX_STATIC_ASSERT(sizeof(bgfx::VertexDecl) == sizeof(bgfx_vertex_decl_t) ); -BX_STATIC_ASSERT(sizeof(bgfx::TransientIndexBuffer) == sizeof(bgfx_transient_index_buffer_t) ); -BX_STATIC_ASSERT(sizeof(bgfx::TransientVertexBuffer) == sizeof(bgfx_transient_vertex_buffer_t) ); -BX_STATIC_ASSERT(sizeof(bgfx::InstanceDataBuffer) == sizeof(bgfx_instance_data_buffer_t) ); -BX_STATIC_ASSERT(sizeof(bgfx::TextureInfo) == sizeof(bgfx_texture_info_t) ); -BX_STATIC_ASSERT(sizeof(bgfx::Caps) == sizeof(bgfx_caps_t) ); -BX_STATIC_ASSERT(sizeof(bgfx::PlatformData) == sizeof(bgfx_platform_data_t) ); -BX_STATIC_ASSERT(sizeof(bgfx::InternalData) == sizeof(bgfx_internal_data_t) ); +#define BGFX_C99_ENUM_CHECK(_enum, _c99enumcount) \ + BX_STATIC_ASSERT(_enum::Count == _enum::Enum(_c99enumcount) ) + +BGFX_C99_ENUM_CHECK(bgfx::Fatal, BGFX_FATAL_COUNT); +BGFX_C99_ENUM_CHECK(bgfx::RendererType, BGFX_RENDERER_TYPE_COUNT); +BGFX_C99_ENUM_CHECK(bgfx::Attrib, BGFX_ATTRIB_COUNT); +BGFX_C99_ENUM_CHECK(bgfx::AttribType, BGFX_ATTRIB_TYPE_COUNT); +BGFX_C99_ENUM_CHECK(bgfx::TextureFormat, BGFX_TEXTURE_FORMAT_COUNT); +BGFX_C99_ENUM_CHECK(bgfx::UniformType, BGFX_UNIFORM_TYPE_COUNT); +BGFX_C99_ENUM_CHECK(bgfx::BackbufferRatio, BGFX_BACKBUFFER_RATIO_COUNT); +BGFX_C99_ENUM_CHECK(bgfx::OcclusionQueryResult, BGFX_OCCLUSION_QUERY_RESULT_COUNT); +BGFX_C99_ENUM_CHECK(bgfx::TopologyConvert, BGFX_TOPOLOGY_CONVERT_COUNT); +BGFX_C99_ENUM_CHECK(bgfx::RenderFrame, BGFX_RENDER_FRAME_COUNT); +#undef BGFX_C99_ENUM_CHECK + +#define BGFX_C99_STRUCT_SIZE_CHECK(_cppstruct, _c99struct) \ + BX_STATIC_ASSERT(sizeof(_cppstruct) == sizeof(_c99struct) ) + +BGFX_C99_STRUCT_SIZE_CHECK(bgfx::Memory, bgfx_memory_t); +BGFX_C99_STRUCT_SIZE_CHECK(bgfx::VertexDecl, bgfx_vertex_decl_t); +BGFX_C99_STRUCT_SIZE_CHECK(bgfx::TransientIndexBuffer, bgfx_transient_index_buffer_t); +BGFX_C99_STRUCT_SIZE_CHECK(bgfx::TransientVertexBuffer, bgfx_transient_vertex_buffer_t); +BGFX_C99_STRUCT_SIZE_CHECK(bgfx::InstanceDataBuffer, bgfx_instance_data_buffer_t); +BGFX_C99_STRUCT_SIZE_CHECK(bgfx::TextureInfo, bgfx_texture_info_t); +BGFX_C99_STRUCT_SIZE_CHECK(bgfx::Caps, bgfx_caps_t); +BGFX_C99_STRUCT_SIZE_CHECK(bgfx::PlatformData, bgfx_platform_data_t); +BGFX_C99_STRUCT_SIZE_CHECK(bgfx::InternalData, bgfx_internal_data_t); +#undef BGFX_C99_STRUCT_SIZE_CHECK namespace bgfx { @@ -3738,6 +3810,11 @@ BGFX_C_API uint16_t bgfx_weld_vertices(uint16_t* _output, const bgfx_vertex_decl return bgfx::weldVertices(_output, decl, _data, _num, _epsilon); } +uint32_t bgfx_topology_convert(bgfx_topology_convert_t _conversion, void* _dst, uint32_t _dstSize, const void* _indices, uint32_t _numIndices, bool _index32) +{ + return bgfx::topologyConvert(bgfx::TopologyConvert::Enum(_conversion), _dst, _dstSize, _indices, _numIndices, _index32); +} + BGFX_C_API void bgfx_image_swizzle_bgra8(uint32_t _width, uint32_t _height, uint32_t _pitch, const void* _src, void* _dst) { bgfx::imageSwizzleBgra8(_width, _height, _pitch, _src, _dst); @@ -4317,10 +4394,10 @@ BGFX_C_API void bgfx_set_vertex_buffer(bgfx_vertex_buffer_handle_t _handle, uint bgfx::setVertexBuffer(handle.cpp, _startVertex, _numVertices); } -BGFX_C_API void bgfx_set_dynamic_vertex_buffer(bgfx_dynamic_vertex_buffer_handle_t _handle, uint32_t _numVertices) +BGFX_C_API void bgfx_set_dynamic_vertex_buffer(bgfx_dynamic_vertex_buffer_handle_t _handle, uint32_t _startVertex, uint32_t _numVertices) { union { bgfx_dynamic_vertex_buffer_handle_t c; bgfx::DynamicVertexBufferHandle cpp; } handle = { _handle }; - bgfx::setVertexBuffer(handle.cpp, _numVertices); + bgfx::setVertexBuffer(handle.cpp, _startVertex, _numVertices); } BGFX_C_API void bgfx_set_transient_vertex_buffer(const bgfx_transient_vertex_buffer_t* _tvb, uint32_t _startVertex, uint32_t _numVertices) @@ -4364,24 +4441,24 @@ BGFX_C_API uint32_t bgfx_touch(uint8_t _id) return bgfx::touch(_id); } -BGFX_C_API uint32_t bgfx_submit(uint8_t _id, bgfx_program_handle_t _handle, int32_t _depth) +BGFX_C_API uint32_t bgfx_submit(uint8_t _id, bgfx_program_handle_t _handle, int32_t _depth, bool _preserveState) { union { bgfx_program_handle_t c; bgfx::ProgramHandle cpp; } handle = { _handle }; - return bgfx::submit(_id, handle.cpp, _depth); + return bgfx::submit(_id, handle.cpp, _depth, _preserveState); } -BGFX_C_API uint32_t bgfx_submit_occlusion_query(uint8_t _id, bgfx_program_handle_t _program, bgfx_occlusion_query_handle_t _occlusionQuery, int32_t _depth) +BGFX_C_API uint32_t bgfx_submit_occlusion_query(uint8_t _id, bgfx_program_handle_t _program, bgfx_occlusion_query_handle_t _occlusionQuery, int32_t _depth, bool _preserveState) { union { bgfx_program_handle_t c; bgfx::ProgramHandle cpp; } program = { _program }; union { bgfx_occlusion_query_handle c; bgfx::OcclusionQueryHandle cpp; } occlusionQuery = { _occlusionQuery }; - return bgfx::submit(_id, program.cpp, occlusionQuery.cpp, _depth); + return bgfx::submit(_id, program.cpp, occlusionQuery.cpp, _depth, _preserveState); } -BGFX_C_API uint32_t bgfx_submit_indirect(uint8_t _id, bgfx_program_handle_t _handle, bgfx_indirect_buffer_handle_t _indirectHandle, uint16_t _start, uint16_t _num, int32_t _depth) +BGFX_C_API uint32_t bgfx_submit_indirect(uint8_t _id, bgfx_program_handle_t _handle, bgfx_indirect_buffer_handle_t _indirectHandle, uint16_t _start, uint16_t _num, int32_t _depth, bool _preserveState) { union { bgfx_program_handle_t c; bgfx::ProgramHandle cpp; } handle = { _handle }; union { bgfx_indirect_buffer_handle_t c; bgfx::IndirectBufferHandle cpp; } indirectHandle = { _indirectHandle }; - return bgfx::submit(_id, handle.cpp, indirectHandle.cpp, _start, _num, _depth); + return bgfx::submit(_id, handle.cpp, indirectHandle.cpp, _start, _num, _depth, _preserveState); } BGFX_C_API void bgfx_set_image(uint8_t _stage, bgfx_uniform_handle_t _sampler, bgfx_texture_handle_t _handle, uint8_t _mip, bgfx_access_t _access, bgfx_texture_format_t _format) @@ -4510,6 +4587,7 @@ BGFX_C_API bgfx_interface_vtbl_t* bgfx_get_interface(uint32_t _version) BGFX_IMPORT_FUNC(vertex_unpack) \ BGFX_IMPORT_FUNC(vertex_convert) \ BGFX_IMPORT_FUNC(weld_vertices) \ + BGFX_IMPORT_FUNC(topology_convert) \ BGFX_IMPORT_FUNC(image_swizzle_bgra8) \ BGFX_IMPORT_FUNC(image_rgba8_downsample_2x2) \ BGFX_IMPORT_FUNC(get_supported_renderers) \ diff --git a/3rdparty/bgfx/src/bgfx_p.h b/3rdparty/bgfx/src/bgfx_p.h index 1434b5ca41f..c56d8691794 100644 --- a/3rdparty/bgfx/src/bgfx_p.h +++ b/3rdparty/bgfx/src/bgfx_p.h @@ -332,6 +332,7 @@ namespace bgfx void release(const Memory* _mem); const char* getAttribName(Attrib::Enum _attr); void getTextureSizeFromRatio(BackbufferRatio::Enum _ratio, uint16_t& _width, uint16_t& _height); + TextureFormat::Enum getViableTextureFormat(const ImageContainer& _imageContainer); inline uint32_t castfu(float _value) { @@ -504,7 +505,7 @@ namespace bgfx { uint32_t* tempKeys = (uint32_t*)alloca(sizeof(m_keys) ); uint32_t* tempValues = (uint32_t*)alloca(sizeof(m_values) ); - bx::radixSort32(m_keys, tempKeys, m_values, tempValues, m_num); + bx::radixSort(m_keys, tempKeys, m_values, tempValues, m_num); return true; } @@ -626,7 +627,7 @@ namespace bgfx void write(const void* _data, uint32_t _size) { BX_CHECK(m_size == BGFX_CONFIG_MAX_COMMAND_BUFFER_SIZE, "Called write outside start/finish?"); - BX_CHECK(m_pos < m_size, ""); + BX_CHECK(m_pos < m_size, "CommandBuffer::write error (pos: %d, size: %d).", m_pos, m_size); memcpy(&m_buffer[m_pos], _data, _size); m_pos += _size; } @@ -640,7 +641,7 @@ namespace bgfx void read(void* _data, uint32_t _size) { - BX_CHECK(m_pos < m_size, ""); + BX_CHECK(m_pos < m_size, "CommandBuffer::read error (pos: %d, size: %d).", m_pos, m_size); memcpy(_data, &m_buffer[m_pos], _size); m_pos += _size; } @@ -654,7 +655,7 @@ namespace bgfx const uint8_t* skip(uint32_t _size) { - BX_CHECK(m_pos < m_size, ""); + BX_CHECK(m_pos < m_size, "CommandBuffer::skip error (pos: %d, size: %d).", m_pos, m_size); const uint8_t* result = &m_buffer[m_pos]; m_pos += _size; return result; @@ -1245,8 +1246,8 @@ namespace bgfx uint32_t m_startVertex; uint32_t m_numVertices; uint32_t m_instanceDataOffset; + uint32_t m_numInstances; uint16_t m_instanceDataStride; - uint16_t m_numInstances; uint16_t m_startIndirect; uint16_t m_numIndirect; uint16_t m_num; @@ -1537,10 +1538,10 @@ namespace bgfx m_draw.m_vertexBuffer = _handle; } - void setVertexBuffer(const DynamicVertexBuffer& _dvb, uint32_t _numVertices) + void setVertexBuffer(const DynamicVertexBuffer& _dvb, uint32_t _startVertex, uint32_t _numVertices) { - m_draw.m_startVertex = _dvb.m_startVertex; - m_draw.m_numVertices = bx::uint32_min(_dvb.m_numVertices, _numVertices); + m_draw.m_startVertex = _dvb.m_startVertex + _startVertex; + m_draw.m_numVertices = bx::uint32_min(bx::uint32_imax(0, _dvb.m_numVertices - _startVertex), _numVertices); m_draw.m_vertexBuffer = _dvb.m_handle; m_draw.m_vertexDecl = _dvb.m_decl; } @@ -1548,7 +1549,7 @@ namespace bgfx void setVertexBuffer(const TransientVertexBuffer* _tvb, uint32_t _startVertex, uint32_t _numVertices) { m_draw.m_startVertex = _tvb->startVertex + _startVertex; - m_draw.m_numVertices = bx::uint32_min(_tvb->size/_tvb->stride, _numVertices); + m_draw.m_numVertices = bx::uint32_min(bx::uint32_imax(0, _tvb->size/_tvb->stride - _startVertex), _numVertices); m_draw.m_vertexBuffer = _tvb->handle; m_draw.m_vertexDecl = _tvb->decl; } @@ -1557,7 +1558,7 @@ namespace bgfx { m_draw.m_instanceDataOffset = _idb->offset; m_draw.m_instanceDataStride = _idb->stride; - m_draw.m_numInstances = uint16_t(bx::uint32_min(_idb->num, _num) ); + m_draw.m_numInstances = bx::uint32_min(_idb->num, _num); m_draw.m_instanceDataBuffer = _idb->handle; BX_FREE(g_allocator, const_cast<InstanceDataBuffer*>(_idb) ); } @@ -1566,7 +1567,7 @@ namespace bgfx { m_draw.m_instanceDataOffset = _startVertex * _stride; m_draw.m_instanceDataStride = _stride; - m_draw.m_numInstances = uint16_t(_num); + m_draw.m_numInstances = _num; m_draw.m_instanceDataBuffer = _handle; } @@ -1631,15 +1632,15 @@ namespace bgfx m_stateFlags = BGFX_STATE_NONE; } - uint32_t submit(uint8_t _id, ProgramHandle _program, OcclusionQueryHandle _occlusionQuery, int32_t _depth); + uint32_t submit(uint8_t _id, ProgramHandle _program, OcclusionQueryHandle _occlusionQuery, int32_t _depth, bool _preserveState); - uint32_t submit(uint8_t _id, ProgramHandle _program, IndirectBufferHandle _indirectHandle, uint16_t _start, uint16_t _num, int32_t _depth) + uint32_t submit(uint8_t _id, ProgramHandle _program, IndirectBufferHandle _indirectHandle, uint16_t _start, uint16_t _num, int32_t _depth, bool _preserveState) { m_draw.m_startIndirect = _start; m_draw.m_numIndirect = _num; m_draw.m_indirectBuffer = _indirectHandle; OcclusionQueryHandle handle = BGFX_INVALID_HANDLE; - return submit(_id, _program, handle, _depth); + return submit(_id, _program, handle, _depth, _preserveState); } uint32_t dispatch(uint8_t _id, ProgramHandle _handle, uint16_t _ngx, uint16_t _ngy, uint16_t _ngz, uint8_t _flags); @@ -2281,12 +2282,14 @@ namespace bgfx return ptr; } + uint32_t allocSize = bx::uint32_max(BGFX_CONFIG_DYNAMIC_INDEX_BUFFER_SIZE, _size); + CommandBuffer& cmdbuf = getCommandBuffer(CommandBuffer::CreateDynamicIndexBuffer); cmdbuf.write(indexBufferHandle); - cmdbuf.write(BGFX_CONFIG_DYNAMIC_INDEX_BUFFER_SIZE); + cmdbuf.write(allocSize); cmdbuf.write(_flags); - m_dynIndexBufferAllocator.add(uint64_t(indexBufferHandle.idx) << 32, BGFX_CONFIG_DYNAMIC_INDEX_BUFFER_SIZE); + m_dynIndexBufferAllocator.add(uint64_t(indexBufferHandle.idx) << 32, allocSize); ptr = m_dynIndexBufferAllocator.alloc(_size); } @@ -2431,12 +2434,14 @@ namespace bgfx return NonLocalAllocator::invalidBlock; } + uint32_t allocSize = bx::uint32_max(BGFX_CONFIG_DYNAMIC_VERTEX_BUFFER_SIZE, _size); + CommandBuffer& cmdbuf = getCommandBuffer(CommandBuffer::CreateDynamicVertexBuffer); cmdbuf.write(vertexBufferHandle); - cmdbuf.write(BGFX_CONFIG_DYNAMIC_VERTEX_BUFFER_SIZE); + cmdbuf.write(allocSize); cmdbuf.write(_flags); - m_dynVertexBufferAllocator.add(uint64_t(vertexBufferHandle.idx)<<32, BGFX_CONFIG_DYNAMIC_VERTEX_BUFFER_SIZE); + m_dynVertexBufferAllocator.add(uint64_t(vertexBufferHandle.idx) << 32, allocSize); ptr = m_dynVertexBufferAllocator.alloc(_size); } @@ -2493,8 +2498,7 @@ namespace bgfx BGFX_API_FUNC(DynamicVertexBufferHandle createDynamicVertexBuffer(const Memory* _mem, const VertexDecl& _decl, uint16_t _flags) ) { uint32_t numVertices = _mem->size/_decl.m_stride; - BX_CHECK(numVertices <= UINT16_MAX, "Num vertices exceeds maximum (num %d, max %d).", numVertices, UINT16_MAX); - DynamicVertexBufferHandle handle = createDynamicVertexBuffer(uint16_t(numVertices), _decl, _flags); + DynamicVertexBufferHandle handle = createDynamicVertexBuffer(numVertices, _decl, _flags); if (isValid(handle) ) { updateDynamicVertexBuffer(handle, 0, _mem); @@ -2794,14 +2798,14 @@ namespace bgfx for (uint32_t ii = 0; ii < count; ++ii) { - uint8_t nameSize; + uint8_t nameSize = 0; bx::read(&reader, nameSize); char name[256]; bx::read(&reader, &name, nameSize); name[nameSize] = '\0'; - uint8_t type; + uint8_t type = 0; bx::read(&reader, type); type &= ~BGFX_UNIFORM_MASK; @@ -3649,10 +3653,10 @@ namespace bgfx m_submit->setVertexBuffer(_handle, _startVertex, _numVertices); } - BGFX_API_FUNC(void setVertexBuffer(DynamicVertexBufferHandle _handle, uint32_t _numVertices) ) + BGFX_API_FUNC(void setVertexBuffer(DynamicVertexBufferHandle _handle, uint32_t _startVertex, uint32_t _numVertices) ) { BGFX_CHECK_HANDLE("setVertexBuffer", m_dynamicVertexBufferHandle, _handle); - m_submit->setVertexBuffer(m_dynamicVertexBuffers[_handle.idx], _numVertices); + m_submit->setVertexBuffer(m_dynamicVertexBuffers[_handle.idx], _startVertex, _numVertices); } BGFX_API_FUNC(void setVertexBuffer(const TransientVertexBuffer* _tvb, uint32_t _startVertex, uint32_t _numVertices) ) @@ -3708,11 +3712,12 @@ namespace bgfx m_submit->setTexture(_stage, _sampler, textureHandle, _flags); } - BGFX_API_FUNC(uint32_t submit(uint8_t _id, ProgramHandle _program, OcclusionQueryHandle _occlusionQuery, int32_t _depth) ) + BGFX_API_FUNC(uint32_t submit(uint8_t _id, ProgramHandle _program, OcclusionQueryHandle _occlusionQuery, int32_t _depth, bool _preserveState) ) { BGFX_CHECK_HANDLE_INVALID_OK("submit", m_programHandle, _program); BGFX_CHECK_HANDLE_INVALID_OK("submit", m_occlusionQueryHandle, _occlusionQuery); - if (BX_ENABLED(BGFX_CONFIG_DEBUG_UNIFORM) ) + if (BX_ENABLED(BGFX_CONFIG_DEBUG_UNIFORM) + && !_preserveState) { m_uniformSet.clear(); } @@ -3727,18 +3732,19 @@ namespace bgfx m_occlusionQuerySet.insert(_occlusionQuery.idx); } - return m_submit->submit(_id, _program, _occlusionQuery, _depth); + return m_submit->submit(_id, _program, _occlusionQuery, _depth, _preserveState); } - BGFX_API_FUNC(uint32_t submit(uint8_t _id, ProgramHandle _handle, IndirectBufferHandle _indirectHandle, uint16_t _start, uint16_t _num, int32_t _depth) ) + BGFX_API_FUNC(uint32_t submit(uint8_t _id, ProgramHandle _handle, IndirectBufferHandle _indirectHandle, uint16_t _start, uint16_t _num, int32_t _depth, bool _preserveState) ) { BGFX_CHECK_HANDLE_INVALID_OK("submit", m_programHandle, _handle); BGFX_CHECK_HANDLE("submit", m_vertexBufferHandle, _indirectHandle); - if (BX_ENABLED(BGFX_CONFIG_DEBUG_UNIFORM) ) + if (BX_ENABLED(BGFX_CONFIG_DEBUG_UNIFORM) + && !_preserveState) { m_uniformSet.clear(); } - return m_submit->submit(_id, _handle, _indirectHandle, _start, _num, _depth); + return m_submit->submit(_id, _handle, _indirectHandle, _start, _num, _depth, _preserveState); } BGFX_API_FUNC(void setBuffer(uint8_t _stage, IndexBufferHandle _handle, Access::Enum _access) ) diff --git a/3rdparty/bgfx/src/bgfx_shader.sh b/3rdparty/bgfx/src/bgfx_shader.sh index 77998652e9d..a675fb6e68c 100644 --- a/3rdparty/bgfx/src/bgfx_shader.sh +++ b/3rdparty/bgfx/src/bgfx_shader.sh @@ -39,6 +39,13 @@ # define bvec4 bool4 # if BGFX_SHADER_LANGUAGE_HLSL > 3 +# if BGFX_SHADER_LANGUAGE_HLSL > 4 +# define dFdxCoarse(_x) ddx_coarse(_x) +# define dFdxFine(_x) ddx_fine(_x) +# define dFdyCoarse(_y) ddy_coarse(-_y) +# define dFdyFine(_y) ddy_fine(-_y) +# endif // BGFX_SHADER_LANGUAGE_HLSL > 4 + struct BgfxSampler2D { SamplerState m_sampler; @@ -239,14 +246,6 @@ float bgfxShadow2DProj(sampler2DShadow _sampler, vec4 _coord) # endif // BGFX_SHADER_LANGUAGE_HLSL > 3 -vec2 vec2_splat(float _x) { return vec2(_x, _x); } -vec3 vec3_splat(float _x) { return vec3(_x, _x, _x); } -vec4 vec4_splat(float _x) { return vec4(_x, _x, _x, _x); } - -uvec2 uvec2_splat(uint _x) { return uvec2(_x, _x); } -uvec3 uvec3_splat(uint _x) { return uvec3(_x, _x, _x); } -uvec4 uvec4_splat(uint _x) { return uvec4(_x, _x, _x, _x); } - vec3 instMul(vec3 _vec, mat3 _mtx) { return mul(_mtx, _vec); } vec3 instMul(mat3 _mtx, vec3 _vec) { return mul(_vec, _mtx); } vec4 instMul(vec4 _vec, mat4 _mtx) { return mul(_mtx, _vec); } @@ -294,12 +293,6 @@ vec4 mod(vec4 _a, vec4 _b) { return _a - _b * floor(_a / _b); } # define SAMPLER3D(_name, _reg) uniform sampler3D _name # define SAMPLERCUBE(_name, _reg) uniform samplerCube _name # define SAMPLER2DSHADOW(_name, _reg) uniform sampler2DShadow _name -# define vec2_splat(_x) vec2(_x) -# define vec3_splat(_x) vec3(_x) -# define vec4_splat(_x) vec4(_x) -# define uvec2_splat(_x) uvec2(_x) -# define uvec3_splat(_x) uvec3(_x) -# define uvec4_splat(_x) uvec4(_x) # if BGFX_SHADER_LANGUAGE_GLSL >= 130 # define ISAMPLER3D(_name, _reg) uniform isampler3D _name @@ -319,6 +312,16 @@ vec3 rcp(vec3 _a) { return vec3(1.0)/_a; } vec4 rcp(vec4 _a) { return vec4(1.0)/_a; } #endif // BGFX_SHADER_LANGUAGE_* +vec2 vec2_splat(float _x) { return vec2(_x, _x); } +vec3 vec3_splat(float _x) { return vec3(_x, _x, _x); } +vec4 vec4_splat(float _x) { return vec4(_x, _x, _x, _x); } + +#if BGFX_SHADER_LANGUAGE_GLSL >= 130 || BGFX_SHADER_LANGUAGE_HLSL +uvec2 uvec2_splat(uint _x) { return uvec2(_x, _x); } +uvec3 uvec3_splat(uint _x) { return uvec3(_x, _x, _x); } +uvec4 uvec4_splat(uint _x) { return uvec4(_x, _x, _x, _x); } +#endif // BGFX_SHADER_LANGUAGE_GLSL >= 130 || BGFX_SHADER_LANGUAGE_HLSL + uniform vec4 u_viewRect; uniform vec4 u_viewTexel; uniform mat4 u_view; diff --git a/3rdparty/bgfx/src/config.h b/3rdparty/bgfx/src/config.h index edfa69da75a..a0ccbe1dd06 100644 --- a/3rdparty/bgfx/src/config.h +++ b/3rdparty/bgfx/src/config.h @@ -32,12 +32,14 @@ # define BGFX_CONFIG_RENDERER_DIRECT3D11 (0 \ || BX_PLATFORM_WINDOWS \ || BX_PLATFORM_WINRT \ + || BX_PLATFORM_XBOXONE \ ? 1 : 0) # endif // BGFX_CONFIG_RENDERER_DIRECT3D11 # ifndef BGFX_CONFIG_RENDERER_DIRECT3D12 # define BGFX_CONFIG_RENDERER_DIRECT3D12 (0 \ || BX_PLATFORM_WINDOWS \ + || BX_PLATFORM_XBOXONE \ ? 1 : 0) # endif // BGFX_CONFIG_RENDERER_DIRECT3D12 diff --git a/3rdparty/bgfx/src/glcontext_ppapi.cpp b/3rdparty/bgfx/src/glcontext_ppapi.cpp index a4887103e63..c0c2c45aea6 100644 --- a/3rdparty/bgfx/src/glcontext_ppapi.cpp +++ b/3rdparty/bgfx/src/glcontext_ppapi.cpp @@ -121,15 +121,13 @@ namespace bgfx { namespace gl static void GL_APIENTRY naclGetQueryObjectiv(GLuint _id, GLenum _pname, GLint* _params) { - BX_UNUSED(_id); - BX_UNUSED(_pname); + BX_UNUSED(_id, _pname); s_ppapi.m_query->GetQueryivEXT(s_ppapi.m_context, GL_ANY_SAMPLES_PASSED_EXT, GL_CURRENT_QUERY_EXT, _params); } static void GL_APIENTRY naclGetQueryObjectui64v(GLuint _id, GLenum _pname, GLuint64* _params) { - BX_UNUSED(_id); - BX_UNUSED(_pname); + BX_UNUSED(_id, _pname); GLint params; s_ppapi.m_query->GetQueryivEXT(s_ppapi.m_context, GL_ANY_SAMPLES_PASSED_EXT, GL_CURRENT_QUERY_EXT, ¶ms); *_params = params; diff --git a/3rdparty/bgfx/src/image.cpp b/3rdparty/bgfx/src/image.cpp index 3a5c0d592b5..5b25a1df6b5 100644 --- a/3rdparty/bgfx/src/image.cpp +++ b/3rdparty/bgfx/src/image.cpp @@ -64,6 +64,10 @@ namespace bgfx { 64, 1, 1, 8, 1, 1, 0, 0, uint8_t(EncodingType::Int ) }, // RG32I { 64, 1, 1, 8, 1, 1, 0, 0, uint8_t(EncodingType::Uint ) }, // RG32U { 64, 1, 1, 8, 1, 1, 0, 0, uint8_t(EncodingType::Float) }, // RG32F + { 24, 1, 1, 3, 1, 1, 0, 0, uint8_t(EncodingType::Unorm) }, // RGB8 + { 24, 1, 1, 3, 1, 1, 0, 0, uint8_t(EncodingType::Int ) }, // RGB8I + { 24, 1, 1, 3, 1, 1, 0, 0, uint8_t(EncodingType::Uint ) }, // RGB8U + { 24, 1, 1, 3, 1, 1, 0, 0, uint8_t(EncodingType::Snorm) }, // RGB8S { 32, 1, 1, 4, 1, 1, 0, 0, uint8_t(EncodingType::Float) }, // RGB9E5F { 32, 1, 1, 4, 1, 1, 0, 0, uint8_t(EncodingType::Unorm) }, // BGRA8 { 32, 1, 1, 4, 1, 1, 0, 0, uint8_t(EncodingType::Unorm) }, // RGBA8 @@ -141,6 +145,10 @@ namespace bgfx "RG32I", // RG32I "RG32U", // RG32U "RG32F", // RG32F + "RGB8", // RGB8 + "RGB8I", // RGB8I + "RGB8U", // RGB8U + "RGB8S", // RGB8S "RGB9E5", // RGB9E5F "BGRA8", // BGRA8 "RGBA8", // RGBA8 @@ -717,23 +725,72 @@ namespace bgfx _dst[1] = float(src[1]); } - // RGBA8 - void packRgba8(void* _dst, const float* _src) + // RGB8 + void packRgb8(void* _dst, const float* _src) { uint8_t* dst = (uint8_t*)_dst; dst[0] = uint8_t(toUnorm(_src[0], 255.0f) ); dst[1] = uint8_t(toUnorm(_src[1], 255.0f) ); dst[2] = uint8_t(toUnorm(_src[2], 255.0f) ); - dst[3] = uint8_t(toUnorm(_src[3], 255.0f) ); } - void unpackRgba8(float* _dst, const void* _src) + void unpackRgb8(float* _dst, const void* _src) { const uint8_t* src = (const uint8_t*)_src; _dst[0] = fromUnorm(src[0], 255.0f); _dst[1] = fromUnorm(src[1], 255.0f); _dst[2] = fromUnorm(src[2], 255.0f); - _dst[3] = fromUnorm(src[3], 255.0f); + } + + // RGB8S + void packRgb8S(void* _dst, const float* _src) + { + int8_t* dst = (int8_t*)_dst; + dst[0] = int8_t(toSnorm(_src[0], 127.0f) ); + dst[1] = int8_t(toSnorm(_src[1], 127.0f) ); + dst[2] = int8_t(toSnorm(_src[2], 127.0f) ); + } + + void unpackRgb8S(float* _dst, const void* _src) + { + const int8_t* src = (const int8_t*)_src; + _dst[0] = fromSnorm(src[0], 127.0f); + _dst[1] = fromSnorm(src[1], 127.0f); + _dst[2] = fromSnorm(src[2], 127.0f); + } + + // RGB8I + void packRgb8I(void* _dst, const float* _src) + { + int8_t* dst = (int8_t*)_dst; + dst[0] = int8_t(_src[0]); + dst[1] = int8_t(_src[1]); + dst[2] = int8_t(_src[2]); + } + + void unpackRgb8I(float* _dst, const void* _src) + { + const int8_t* src = (const int8_t*)_src; + _dst[0] = float(src[0]); + _dst[1] = float(src[1]); + _dst[2] = float(src[2]); + } + + // RGB8U + void packRgb8U(void* _dst, const float* _src) + { + uint8_t* dst = (uint8_t*)_dst; + dst[0] = uint8_t(_src[0]); + dst[1] = uint8_t(_src[1]); + dst[2] = uint8_t(_src[2]); + } + + void unpackRgb8U(float* _dst, const void* _src) + { + const uint8_t* src = (const uint8_t*)_src; + _dst[0] = float(src[0]); + _dst[1] = float(src[1]); + _dst[2] = float(src[2]); } // BGRA8 @@ -755,6 +812,25 @@ namespace bgfx _dst[3] = fromUnorm(src[3], 255.0f); } + // RGBA8 + void packRgba8(void* _dst, const float* _src) + { + uint8_t* dst = (uint8_t*)_dst; + dst[0] = uint8_t(toUnorm(_src[0], 255.0f) ); + dst[1] = uint8_t(toUnorm(_src[1], 255.0f) ); + dst[2] = uint8_t(toUnorm(_src[2], 255.0f) ); + dst[3] = uint8_t(toUnorm(_src[3], 255.0f) ); + } + + void unpackRgba8(float* _dst, const void* _src) + { + const uint8_t* src = (const uint8_t*)_src; + _dst[0] = fromUnorm(src[0], 255.0f); + _dst[1] = fromUnorm(src[1], 255.0f); + _dst[2] = fromUnorm(src[2], 255.0f); + _dst[3] = fromUnorm(src[3], 255.0f); + } + // RGBA8S void packRgba8S(void* _dst, const float* _src) { @@ -1218,18 +1294,18 @@ namespace bgfx void packR5G6B5(void* _dst, const float* _src) { *( (uint16_t*)_dst) = 0 - | uint16_t(toUnorm(_src[0], 31.0f) ) + | uint16_t(toUnorm(_src[0], 31.0f)<<11) | uint16_t(toUnorm(_src[1], 63.0f)<< 5) - | uint16_t(toUnorm(_src[2], 31.0f)<<11) + | uint16_t(toUnorm(_src[2], 31.0f) ) ; } void unpackR5G6B5(float* _dst, const void* _src) { uint16_t packed = *( (const uint16_t*)_src); - _dst[0] = float( ( (packed ) & 0x1f) ) / 31.0f; + _dst[0] = float( ( (packed>>11) & 0x1f) ) / 31.0f; _dst[1] = float( ( (packed>> 5) & 0x3f) ) / 63.0f; - _dst[2] = float( ( (packed>>11) & 0x1f) ) / 31.0f; + _dst[2] = float( ( (packed ) & 0x1f) ) / 31.0f; } // RGBA4 @@ -1252,6 +1328,26 @@ namespace bgfx _dst[3] = float( ( (packed>>12) & 0xf) ) / 15.0f; } + // RGBA4 + void packBgra4(void* _dst, const float* _src) + { + *( (uint16_t*)_dst) = 0 + | uint16_t(toUnorm(_src[0], 15.0f)<< 8) + | uint16_t(toUnorm(_src[1], 15.0f)<< 4) + | uint16_t(toUnorm(_src[2], 15.0f) ) + | uint16_t(toUnorm(_src[3], 15.0f)<<12) + ; + } + + void unpackBgra4(float* _dst, const void* _src) + { + uint16_t packed = *( (const uint16_t*)_src); + _dst[0] = float( ( (packed>> 8) & 0xf) ) / 15.0f; + _dst[1] = float( ( (packed>> 4) & 0xf) ) / 15.0f; + _dst[2] = float( ( (packed ) & 0xf) ) / 15.0f; + _dst[3] = float( ( (packed>>12) & 0xf) ) / 15.0f; + } + // RGB5A1 void packRgb5a1(void* _dst, const float* _src) { @@ -1272,6 +1368,26 @@ namespace bgfx _dst[3] = float( ( (packed>>14) & 0x1) ); } + // BGR5A1 + void packBgr5a1(void* _dst, const float* _src) + { + *( (uint16_t*)_dst) = 0 + | uint16_t(toUnorm(_src[0], 31.0f)<<10) + | uint16_t(toUnorm(_src[1], 31.0f)<< 5) + | uint16_t(toUnorm(_src[2], 31.0f) ) + | uint16_t(toUnorm(_src[3], 1.0f)<<15) + ; + } + + void unpackBgr5a1(float* _dst, const void* _src) + { + uint16_t packed = *( (const uint16_t*)_src); + _dst[0] = float( ( (packed>>10) & 0x1f) ) / 31.0f; + _dst[1] = float( ( (packed>> 5) & 0x1f) ) / 31.0f; + _dst[2] = float( ( (packed ) & 0x1f) ) / 31.0f; + _dst[3] = float( ( (packed>>14) & 0x1) ); + } + // RGB10A2 void packRgb10A2(void* _dst, const float* _src) { @@ -1310,9 +1426,6 @@ namespace bgfx _dst[2] = bx::halfToFloat( (packed>>17) & 0x7fe0); } - typedef void (*PackFn)(void*, const float*); - typedef void (*UnpackFn)(float*, const void*); - struct PackUnpack { PackFn pack; @@ -1365,6 +1478,10 @@ namespace bgfx { packRg32I, unpackRg32I }, // RG32I { packRg32U, unpackRg32U }, // RG32U { packRg32F, unpackRg32F }, // RG32F + { packRgb8, unpackRgb8 }, // RGB8 + { packRgb8S, unpackRgb8S }, // RGB8S + { packRgb8I, unpackRgb8I }, // RGB8I + { packRgb8U, unpackRgb8U }, // RGB8U { packRgb9E5F, unpackRgb9E5F }, // RGB9E5F { packBgra8, unpackBgra8 }, // BGRA8 { packRgba8, unpackRgba8 }, // RGBA8 @@ -1396,37 +1513,71 @@ namespace bgfx }; BX_STATIC_ASSERT(TextureFormat::Count == BX_COUNTOF(s_packUnpack) ); - bool imageConvert(void* _dst, TextureFormat::Enum _dstFormat, const void* _src, TextureFormat::Enum _srcFormat, uint32_t _width, uint32_t _height) + bool imageConvert(TextureFormat::Enum _dstFormat, TextureFormat::Enum _srcFormat) { UnpackFn unpack = s_packUnpack[_srcFormat].unpack; PackFn pack = s_packUnpack[_dstFormat].pack; - if (NULL == pack - || NULL == unpack) + return NULL != pack + && NULL != unpack + ; + } + + void imageConvert(void* _dst, uint32_t _bpp, PackFn _pack, const void* _src, UnpackFn _unpack, uint32_t _size) + { + const uint8_t* src = (uint8_t*)_src; + uint8_t* dst = (uint8_t*)_dst; + + const uint32_t size = _size * 8 / _bpp; + + for (uint32_t ii = 0; ii < size; ++ii) { - return false; + float rgba[4]; + _unpack(rgba, &src[ii*_bpp/8]); + _pack(&dst[ii*_bpp/8], rgba); } + } + void imageConvert(void* _dst, uint32_t _dstBpp, PackFn _pack, const void* _src, uint32_t _srcBpp, UnpackFn _unpack, uint32_t _width, uint32_t _height, uint32_t _srcPitch) + { const uint8_t* src = (uint8_t*)_src; uint8_t* dst = (uint8_t*)_dst; - const uint32_t srcBpp = s_imageBlockInfo[_srcFormat].bitsPerPixel; - const uint32_t dstBpp = s_imageBlockInfo[_dstFormat].bitsPerPixel; - const uint32_t srcPitch = _width * srcBpp / 8; - const uint32_t dstPitch = _width * dstBpp / 8; + const uint32_t dstPitch = _width * _dstBpp / 8; - for (uint32_t yy = 0; yy < _height; ++yy, src += srcPitch, dst += dstPitch) + for (uint32_t yy = 0; yy < _height; ++yy, src += _srcPitch, dst += dstPitch) { for (uint32_t xx = 0; xx < _width; ++xx) { float rgba[4]; - unpack(rgba, &src[xx*srcBpp/8]); - pack(&dst[xx*dstBpp/8], rgba); + _unpack(rgba, &src[xx*_srcBpp/8]); + _pack(&dst[xx*_dstBpp/8], rgba); } } + } + + bool imageConvert(void* _dst, TextureFormat::Enum _dstFormat, const void* _src, TextureFormat::Enum _srcFormat, uint32_t _width, uint32_t _height, uint32_t _srcPitch) + { + UnpackFn unpack = s_packUnpack[_srcFormat].unpack; + PackFn pack = s_packUnpack[_dstFormat].pack; + if (NULL == pack + || NULL == unpack) + { + return false; + } + + const uint32_t srcBpp = s_imageBlockInfo[_srcFormat].bitsPerPixel; + const uint32_t dstBpp = s_imageBlockInfo[_dstFormat].bitsPerPixel; + imageConvert(_dst, dstBpp, pack, _src, srcBpp, unpack, _width, _height, _srcPitch); return true; } + bool imageConvert(void* _dst, TextureFormat::Enum _dstFormat, const void* _src, TextureFormat::Enum _srcFormat, uint32_t _width, uint32_t _height) + { + const uint32_t srcBpp = s_imageBlockInfo[_srcFormat].bitsPerPixel; + return imageConvert(_dst, _dstFormat, _src, _srcFormat, _width, _height, _width*srcBpp); + } + uint8_t bitRangeConvert(uint32_t _in, uint32_t _from, uint32_t _to) { using namespace bx; @@ -2211,9 +2362,9 @@ namespace bgfx } } - const Memory* imageAlloc(ImageContainer& _imageContainer, TextureFormat::Enum _format, uint16_t _width, uint16_t _height, uint16_t _depth, bool _cubeMap, bool _mipsActive) + const Memory* imageAlloc(ImageContainer& _imageContainer, TextureFormat::Enum _format, uint16_t _width, uint16_t _height, uint16_t _depth, bool _cubeMap, bool _generateMips) { - const uint8_t numMips = _mipsActive ? imageGetNumMips(_format, _width, _height) : 1; + const uint8_t numMips = _generateMips ? imageGetNumMips(_format, _width, _height) : 1; uint32_t size = imageGetSize(_format, _width, _height, 0, false, numMips); const Memory* image = alloc(size); @@ -2673,6 +2824,7 @@ namespace bgfx #define KTX_RG16_SNORM 0x8F99 #define KTX_RGB16_SNORM 0x8F9A #define KTX_RGBA16_SNORM 0x8F9B +#define KTX_SRGB8 0x8C41 #define KTX_SRGB8_ALPHA8 0x8C43 #define KTX_RGBA32UI 0x8D70 #define KTX_RGB32UI 0x8D71 @@ -2685,6 +2837,7 @@ namespace bgfx #define KTX_RGBA16I 0x8D88 #define KTX_RGB16I 0x8D89 #define KTX_RGBA8I 0x8D8E +#define KTX_RGB8 0x8051 #define KTX_RGB8I 0x8D8F #define KTX_RGB9_E5 0x8C3D #define KTX_R11F_G11F_B10F 0x8C3A @@ -2766,6 +2919,10 @@ namespace bgfx { KTX_RG32I, KTX_ZERO, KTX_RG, KTX_INT, }, // RG32I { KTX_RG32UI, KTX_ZERO, KTX_RG, KTX_UNSIGNED_INT, }, // RG32U { KTX_RG32F, KTX_ZERO, KTX_RG, KTX_FLOAT, }, // RG32F + { KTX_RGB8, KTX_SRGB8, KTX_RGB, KTX_UNSIGNED_BYTE, }, // RGB8 + { KTX_RGB8I, KTX_ZERO, KTX_RGB, KTX_BYTE, }, // RGB8I + { KTX_RGB8UI, KTX_ZERO, KTX_RGB, KTX_UNSIGNED_BYTE, }, // RGB8U + { KTX_RGB8_SNORM, KTX_ZERO, KTX_RGB, KTX_BYTE, }, // RGB8S { KTX_RGB9_E5, KTX_ZERO, KTX_RGB, KTX_UNSIGNED_INT_5_9_9_9_REV, }, // RGB9E5F { KTX_BGRA, KTX_SRGB8_ALPHA8, KTX_BGRA, KTX_UNSIGNED_BYTE, }, // BGRA8 { KTX_RGBA8, KTX_SRGB8_ALPHA8, KTX_RGBA, KTX_UNSIGNED_BYTE, }, // RGBA8 @@ -3277,8 +3434,11 @@ namespace bgfx break; default: - // Decompression not implemented... Make ugly red-yellow checkerboard texture. - imageCheckerboard(_width, _height, 16, UINT32_C(0xffff0000), UINT32_C(0xffffff00), _dst); + if (!imageConvert(_dst, TextureFormat::BGRA8, _src, _format, _width, _height, _pitch) ) + { + // Failed to convert, just make ugly red-yellow checkerboard texture. + imageCheckerboard(_width, _height, 16, UINT32_C(0xffff0000), UINT32_C(0xffffff00), _dst); + } break; } } @@ -3544,8 +3704,10 @@ namespace bgfx return false; } - void imageWriteTga(bx::WriterI* _writer, uint32_t _width, uint32_t _height, uint32_t _pitch, const void* _src, bool _grayscale, bool _yflip) + void imageWriteTga(bx::WriterI* _writer, uint32_t _width, uint32_t _height, uint32_t _pitch, const void* _src, bool _grayscale, bool _yflip, bx::Error* _err) { + BX_ERROR_SCOPE(_err); + uint8_t type = _grayscale ? 3 : 2; uint8_t bpp = _grayscale ? 8 : 32; @@ -3558,7 +3720,7 @@ namespace bgfx header[16] = bpp; header[17] = 32; - bx::write(_writer, header, sizeof(header) ); + bx::write(_writer, header, sizeof(header), _err); uint32_t dstPitch = _width*bpp/8; if (_yflip) @@ -3566,52 +3728,56 @@ namespace bgfx uint8_t* data = (uint8_t*)_src + _pitch*_height - _pitch; for (uint32_t yy = 0; yy < _height; ++yy) { - bx::write(_writer, data, dstPitch); + bx::write(_writer, data, dstPitch, _err); data -= _pitch; } } else if (_pitch == dstPitch) { - bx::write(_writer, _src, _height*_pitch); + bx::write(_writer, _src, _height*_pitch, _err); } else { uint8_t* data = (uint8_t*)_src; for (uint32_t yy = 0; yy < _height; ++yy) { - bx::write(_writer, data, dstPitch); + bx::write(_writer, data, dstPitch, _err); data += _pitch; } } } - static int32_t imageWriteKtxHeader(bx::WriterI* _writer, TextureFormat::Enum _format, bool _cubeMap, uint32_t _width, uint32_t _height, uint32_t _depth, uint8_t _numMips) + static int32_t imageWriteKtxHeader(bx::WriterI* _writer, TextureFormat::Enum _format, bool _cubeMap, uint32_t _width, uint32_t _height, uint32_t _depth, uint8_t _numMips, bx::Error* _err) { + BX_ERROR_SCOPE(_err); + const KtxFormatInfo& tfi = s_translateKtxFormat[_format]; int32_t size = 0; - size += bx::write(_writer, "\xabKTX 11\xbb\r\n\x1a\n", 12); - size += bx::write(_writer, UINT32_C(0x04030201) ); - size += bx::write(_writer, UINT32_C(0) ); // glType - size += bx::write(_writer, UINT32_C(1) ); // glTypeSize - size += bx::write(_writer, UINT32_C(0) ); // glFormat - size += bx::write(_writer, tfi.m_internalFmt); // glInternalFormat - size += bx::write(_writer, tfi.m_fmt); // glBaseInternalFormat - size += bx::write(_writer, _width); - size += bx::write(_writer, _height); - size += bx::write(_writer, _depth); - size += bx::write(_writer, UINT32_C(0) ); // numberOfArrayElements - size += bx::write(_writer, _cubeMap ? UINT32_C(6) : UINT32_C(0) ); - size += bx::write(_writer, uint32_t(_numMips) ); - size += bx::write(_writer, UINT32_C(0) ); // Meta-data size. - - BX_CHECK(size == 64, "KTX: Failed to write header size %d (expected: %d).", size, 64); + size += bx::write(_writer, "\xabKTX 11\xbb\r\n\x1a\n", 12, _err); + size += bx::write(_writer, UINT32_C(0x04030201), _err); + size += bx::write(_writer, UINT32_C(0), _err); // glType + size += bx::write(_writer, UINT32_C(1), _err); // glTypeSize + size += bx::write(_writer, UINT32_C(0), _err); // glFormat + size += bx::write(_writer, tfi.m_internalFmt, _err); // glInternalFormat + size += bx::write(_writer, tfi.m_fmt, _err); // glBaseInternalFormat + size += bx::write(_writer, _width, _err); + size += bx::write(_writer, _height, _err); + size += bx::write(_writer, _depth, _err); + size += bx::write(_writer, UINT32_C(0), _err); // numberOfArrayElements + size += bx::write(_writer, _cubeMap ? UINT32_C(6) : UINT32_C(0), _err); + size += bx::write(_writer, uint32_t(_numMips), _err); + size += bx::write(_writer, UINT32_C(0), _err); // Meta-data size. + + BX_WARN(size == 64, "KTX: Failed to write header size %d (expected: %d).", size, 64); return size; } - void imageWriteKtx(bx::WriterI* _writer, TextureFormat::Enum _format, bool _cubeMap, uint32_t _width, uint32_t _height, uint32_t _depth, uint8_t _numMips, const void* _src) + void imageWriteKtx(bx::WriterI* _writer, TextureFormat::Enum _format, bool _cubeMap, uint32_t _width, uint32_t _height, uint32_t _depth, uint8_t _numMips, const void* _src, bx::Error* _err) { - imageWriteKtxHeader(_writer, _format, _cubeMap, _width, _height, _depth, _numMips); + BX_ERROR_SCOPE(_err); + + imageWriteKtxHeader(_writer, _format, _cubeMap, _width, _height, _depth, _numMips, _err); const ImageBlockInfo& blockInfo = s_imageBlockInfo[_format]; const uint8_t bpp = blockInfo.bitsPerPixel; @@ -3632,11 +3798,11 @@ namespace bgfx depth = bx::uint32_max(1, depth); uint32_t size = width*height*depth*bpp/8; - bx::write(_writer, size); + bx::write(_writer, size, _err); for (uint8_t side = 0, numSides = _cubeMap ? 6 : 1; side < numSides; ++side) { - bx::write(_writer, src, size); + bx::write(_writer, src, size, _err); src += size; } @@ -3646,8 +3812,10 @@ namespace bgfx } } - void imageWriteKtx(bx::WriterI* _writer, ImageContainer& _imageContainer, const void* _data, uint32_t _size) + void imageWriteKtx(bx::WriterI* _writer, ImageContainer& _imageContainer, const void* _data, uint32_t _size, bx::Error* _err) { + BX_ERROR_SCOPE(_err); + imageWriteKtxHeader(_writer , TextureFormat::Enum(_imageContainer.m_format) , _imageContainer.m_cubeMap @@ -3655,19 +3823,20 @@ namespace bgfx , _imageContainer.m_height , _imageContainer.m_depth , _imageContainer.m_numMips + , _err ); for (uint8_t lod = 0, num = _imageContainer.m_numMips; lod < num; ++lod) { ImageMip mip; imageGetRawData(_imageContainer, 0, lod, _data, _size, mip); - bx::write(_writer, mip.m_size); + bx::write(_writer, mip.m_size, _err); for (uint8_t side = 0, numSides = _imageContainer.m_cubeMap ? 6 : 1; side < numSides; ++side) { if (imageGetRawData(_imageContainer, side, lod, _data, _size, mip) ) { - bx::write(_writer, mip.m_data, mip.m_size); + bx::write(_writer, mip.m_data, mip.m_size, _err); } } } diff --git a/3rdparty/bgfx/src/image.h b/3rdparty/bgfx/src/image.h index 1baba0bae68..173cf7b0fff 100644 --- a/3rdparty/bgfx/src/image.h +++ b/3rdparty/bgfx/src/image.h @@ -66,6 +66,205 @@ namespace bgfx uint8_t encoding; }; + typedef void (*PackFn)(void*, const float*); + typedef void (*UnpackFn)(float*, const void*); + + // R8 + void packR8(void* _dst, const float* _src); + void unpackR8(float* _dst, const void* _src); + + // R8S + void packR8S(void* _dst, const float* _src); + void unpackR8S(float* _dst, const void* _src); + + // R8I + void packR8I(void* _dst, const float* _src); + void unpackR8I(float* _dst, const void* _src); + + // R8U + void packR8U(void* _dst, const float* _src); + void unpackR8U(float* _dst, const void* _src); + + // RG8 + void packRg8(void* _dst, const float* _src); + void unpackRg8(float* _dst, const void* _src); + + // RG8S + void packRg8S(void* _dst, const float* _src); + void unpackRg8S(float* _dst, const void* _src); + + // RG8I + void packRg8I(void* _dst, const float* _src); + void unpackRg8I(float* _dst, const void* _src); + + // RG8U + void packRg8U(void* _dst, const float* _src); + void unpackRg8U(float* _dst, const void* _src); + + // RGB8 + void packRgb8(void* _dst, const float* _src); + void unpackRgb8(float* _dst, const void* _src); + + // RGB8S + void packRgb8S(void* _dst, const float* _src); + void unpackRgb8S(float* _dst, const void* _src); + + // RGB8I + void packRgb8I(void* _dst, const float* _src); + void unpackRgb8I(float* _dst, const void* _src); + + // RGB8U + void packRgb8U(void* _dst, const float* _src); + void unpackRgb8U(float* _dst, const void* _src); + + // RGBA8 + void packRgba8(void* _dst, const float* _src); + void unpackRgba8(float* _dst, const void* _src); + + // BGRA8 + void packBgra8(void* _dst, const float* _src); + void unpackBgra8(float* _dst, const void* _src); + + // RGBA8S + void packRgba8S(void* _dst, const float* _src); + void unpackRgba8S(float* _dst, const void* _src); + + // RGBA8I + void packRgba8I(void* _dst, const float* _src); + void unpackRgba8I(float* _dst, const void* _src); + + // RGBA8U + void packRgba8U(void* _dst, const float* _src); + void unpackRgba8U(float* _dst, const void* _src); + + // R16 + void packR16(void* _dst, const float* _src); + void unpackR16(float* _dst, const void* _src); + + // R16S + void packR16S(void* _dst, const float* _src); + void unpackR16S(float* _dst, const void* _src); + + // R16I + void packR16I(void* _dst, const float* _src); + void unpackR16I(float* _dst, const void* _src); + + // R16U + void packR16U(void* _dst, const float* _src); + void unpackR16U(float* _dst, const void* _src); + + // R16F + void packR16F(void* _dst, const float* _src); + void unpackR16F(float* _dst, const void* _src); + + // RG16 + void packRg16(void* _dst, const float* _src); + void unpackRg16(float* _dst, const void* _src); + + // RG16S + void packRg16S(void* _dst, const float* _src); + void unpackRg16S(float* _dst, const void* _src); + + // RG16I + void packRg16I(void* _dst, const float* _src); + void unpackRg16I(float* _dst, const void* _src); + + // RG16U + void packRg16U(void* _dst, const float* _src); + void unpackRg16U(float* _dst, const void* _src); + + // RG16F + void packRg16F(void* _dst, const float* _src); + void unpackRg16F(float* _dst, const void* _src); + + // RGBA16 + void packRgba16(void* _dst, const float* _src); + void unpackRgba16(float* _dst, const void* _src); + + // RGBA16S + void packRgba16S(void* _dst, const float* _src); + void unpackRgba16S(float* _dst, const void* _src); + + // RGBA16I + void packRgba16I(void* _dst, const float* _src); + void unpackRgba16I(float* _dst, const void* _src); + + // RGBA16U + void packRgba16U(void* _dst, const float* _src); + void unpackRgba16U(float* _dst, const void* _src); + + // RGBA16F + void packRgba16F(void* _dst, const float* _src); + void unpackRgba16F(float* _dst, const void* _src); + + // R32I + void packR32I(void* _dst, const float* _src); + void unpackR32I(float* _dst, const void* _src); + + // R32U + void packR32U(void* _dst, const float* _src); + void unpackR32U(float* _dst, const void* _src); + + // R32F + void packR32F(void* _dst, const float* _src); + void unpackR32F(float* _dst, const void* _src); + + // RG32I + void packRg32I(void* _dst, const float* _src); + void unpackRg32I(float* _dst, const void* _src); + + // RG32U + void packRg32U(void* _dst, const float* _src); + void unpackRg32U(float* _dst, const void* _src); + + // RGB9E5F + void packRgb9E5F(void* _dst, const float* _src); + void unpackRgb9E5F(float* _dst, const void* _src); + + // RGBA32I + void packRgba32I(void* _dst, const float* _src); + void unpackRgba32I(float* _dst, const void* _src); + + // RGBA32U + void packRgba32U(void* _dst, const float* _src); + void unpackRgba32U(float* _dst, const void* _src); + + // RGBA32F + void packRgba32F(void* _dst, const float* _src); + void unpackRgba32F(float* _dst, const void* _src); + + // R5G6B5 + void packR5G6B5(void* _dst, const float* _src); + void unpackR5G6B5(float* _dst, const void* _src); + + // RGBA4 + void packRgba4(void* _dst, const float* _src); + void unpackRgba4(float* _dst, const void* _src); + + // RGBA4 + void packBgra4(void* _dst, const float* _src); + void unpackBgra4(float* _dst, const void* _src); + + // RGB5A1 + void packRgb5a1(void* _dst, const float* _src); + void unpackRgb5a1(float* _dst, const void* _src); + + // BGR5A1 + void packBgr5a1(void* _dst, const float* _src); + void unpackBgr5a1(float* _dst, const void* _src); + + // RGB10A2 + void packRgb10A2(void* _dst, const float* _src); + void unpackRgb10A2(float* _dst, const void* _src); + + // R11G11B10F + void packR11G11B10F(void* _dst, const float* _src); + void unpackR11G11B10F(float* _dst, const void* _src); + + // RG32F + void packRg32F(void* _dst, const float* _src); + void unpackRg32F(float* _dst, const void* _src); + /// Returns true if texture format is compressed. bool isCompressed(TextureFormat::Enum _format); @@ -118,22 +317,31 @@ namespace bgfx void imageCopy(uint32_t _width, uint32_t _height, uint32_t _bpp, uint32_t _pitch, const void* _src, void* _dst); /// + bool imageConvert(TextureFormat::Enum _dstFormat, TextureFormat::Enum _srcFormat); + + /// + void imageConvert(void* _dst, uint32_t _bpp, PackFn _pack, const void* _src, UnpackFn _unpack, uint32_t _size); + + /// + void imageConvert(void* _dst, uint32_t _dstBpp, PackFn _pack, const void* _src, uint32_t _srcBpp, UnpackFn _unpack, uint32_t _width, uint32_t _height, uint32_t _srcPitch); + + /// bool imageConvert(void* _dst, TextureFormat::Enum _dstFormat, const void* _src, TextureFormat::Enum _srcFormat, uint32_t _width, uint32_t _height); /// - const Memory* imageAlloc(ImageContainer& _imageContainer, TextureFormat::Enum _format, uint16_t _width, uint16_t _height, uint16_t _depth = 0, bool _cubeMap = false, bool _mipsActive = false); + const Memory* imageAlloc(ImageContainer& _imageContainer, TextureFormat::Enum _format, uint16_t _width, uint16_t _height, uint16_t _depth = 0, bool _cubeMap = false, bool _generateMips = false); /// void imageFree(const Memory* _memory); /// - void imageWriteTga(bx::WriterI* _writer, uint32_t _width, uint32_t _height, uint32_t _pitch, const void* _src, bool _grayscale, bool _yflip); + void imageWriteTga(bx::WriterI* _writer, uint32_t _width, uint32_t _height, uint32_t _pitch, const void* _src, bool _grayscale, bool _yflip, bx::Error* _err = NULL); /// - void imageWriteKtx(bx::WriterI* _writer, TextureFormat::Enum _format, bool _cubeMap, uint32_t _width, uint32_t _height, uint32_t _depth, uint8_t _numMips, const void* _src); + void imageWriteKtx(bx::WriterI* _writer, TextureFormat::Enum _format, bool _cubeMap, uint32_t _width, uint32_t _height, uint32_t _depth, uint8_t _numMips, const void* _src, bx::Error* _err = NULL); /// - void imageWriteKtx(bx::WriterI* _writer, ImageContainer& _imageContainer, const void* _data, uint32_t _size); + void imageWriteKtx(bx::WriterI* _writer, ImageContainer& _imageContainer, const void* _data, uint32_t _size, bx::Error* _err = NULL); /// bool imageParse(ImageContainer& _imageContainer, bx::ReaderSeekerI* _reader); diff --git a/3rdparty/bgfx/src/makefile b/3rdparty/bgfx/src/makefile index 84d9bb33869..a09ec27c16b 100644 --- a/3rdparty/bgfx/src/makefile +++ b/3rdparty/bgfx/src/makefile @@ -1,5 +1,5 @@ # -# Copyright 2011-2015 Branimir Karadzic. All rights reserved. +# Copyright 2011-2016 Branimir Karadzic. All rights reserved. # License: http://www.opensource.org/licenses/BSD-2-Clause # diff --git a/3rdparty/bgfx/src/renderer_d3d.h b/3rdparty/bgfx/src/renderer_d3d.h index 314fbaa0f89..97cfb045821 100644 --- a/3rdparty/bgfx/src/renderer_d3d.h +++ b/3rdparty/bgfx/src/renderer_d3d.h @@ -21,6 +21,12 @@ namespace bgfx { +#if BX_PLATFORM_XBOXONE + typedef ::IGraphicsUnknown IUnknown; +#else + typedef ::IUnknown IUnknown; +#endif // BX_PLATFORM_XBOXONE + #define _DX_CHECK(_call) \ BX_MACRO_BLOCK_BEGIN \ HRESULT __hr__ = _call; \ @@ -96,7 +102,7 @@ namespace bgfx return _interface->Release(); } - template <typename Ty> + template<typename Ty> class StateCacheT { public: diff --git a/3rdparty/bgfx/src/renderer_d3d11.cpp b/3rdparty/bgfx/src/renderer_d3d11.cpp index 4446d6b0324..27f1681a0d2 100644 --- a/3rdparty/bgfx/src/renderer_d3d11.cpp +++ b/3rdparty/bgfx/src/renderer_d3d11.cpp @@ -8,10 +8,12 @@ #if BGFX_CONFIG_RENDERER_DIRECT3D11 # include "renderer_d3d11.h" -#if BX_PLATFORM_WINRT +#if !BX_PLATFORM_WINDOWS # include <inspectable.h> -# include <windows.ui.xaml.media.dxinterop.h> -#endif // BX_PLATFORM_WINRT +# if BX_PLATFORM_WINRT +# include <windows.ui.xaml.media.dxinterop.h> +# endif // BX_PLATFORM_WINRT +#endif // !BX_PLATFORM_WINDOWS #if BGFX_CONFIG_PROFILER_REMOTERY # define BGFX_GPU_PROFILER_BIND(_device, _context) rmt_BindD3D11(_device, _context) @@ -101,20 +103,20 @@ namespace bgfx { namespace d3d11 static const D3D11_BLEND s_blendFactor[][2] = { - { (D3D11_BLEND)0, (D3D11_BLEND)0 }, // ignored + { D3D11_BLEND(0), D3D11_BLEND(0) }, // ignored { D3D11_BLEND_ZERO, D3D11_BLEND_ZERO }, // ZERO - { D3D11_BLEND_ONE, D3D11_BLEND_ONE }, // ONE - { D3D11_BLEND_SRC_COLOR, D3D11_BLEND_SRC_ALPHA }, // SRC_COLOR - { D3D11_BLEND_INV_SRC_COLOR, D3D11_BLEND_INV_SRC_ALPHA }, // INV_SRC_COLOR - { D3D11_BLEND_SRC_ALPHA, D3D11_BLEND_SRC_ALPHA }, // SRC_ALPHA - { D3D11_BLEND_INV_SRC_ALPHA, D3D11_BLEND_INV_SRC_ALPHA }, // INV_SRC_ALPHA - { D3D11_BLEND_DEST_ALPHA, D3D11_BLEND_DEST_ALPHA }, // DST_ALPHA - { D3D11_BLEND_INV_DEST_ALPHA, D3D11_BLEND_INV_DEST_ALPHA }, // INV_DST_ALPHA - { D3D11_BLEND_DEST_COLOR, D3D11_BLEND_DEST_ALPHA }, // DST_COLOR - { D3D11_BLEND_INV_DEST_COLOR, D3D11_BLEND_INV_DEST_ALPHA }, // INV_DST_COLOR - { D3D11_BLEND_SRC_ALPHA_SAT, D3D11_BLEND_ONE }, // SRC_ALPHA_SAT - { D3D11_BLEND_BLEND_FACTOR, D3D11_BLEND_BLEND_FACTOR }, // FACTOR - { D3D11_BLEND_INV_BLEND_FACTOR, D3D11_BLEND_INV_BLEND_FACTOR }, // INV_FACTOR + { D3D11_BLEND_ONE, D3D11_BLEND_ONE }, // ONE + { D3D11_BLEND_SRC_COLOR, D3D11_BLEND_SRC_ALPHA }, // SRC_COLOR + { D3D11_BLEND_INV_SRC_COLOR, D3D11_BLEND_INV_SRC_ALPHA }, // INV_SRC_COLOR + { D3D11_BLEND_SRC_ALPHA, D3D11_BLEND_SRC_ALPHA }, // SRC_ALPHA + { D3D11_BLEND_INV_SRC_ALPHA, D3D11_BLEND_INV_SRC_ALPHA }, // INV_SRC_ALPHA + { D3D11_BLEND_DEST_ALPHA, D3D11_BLEND_DEST_ALPHA }, // DST_ALPHA + { D3D11_BLEND_INV_DEST_ALPHA, D3D11_BLEND_INV_DEST_ALPHA }, // INV_DST_ALPHA + { D3D11_BLEND_DEST_COLOR, D3D11_BLEND_DEST_ALPHA }, // DST_COLOR + { D3D11_BLEND_INV_DEST_COLOR, D3D11_BLEND_INV_DEST_ALPHA }, // INV_DST_COLOR + { D3D11_BLEND_SRC_ALPHA_SAT, D3D11_BLEND_ONE }, // SRC_ALPHA_SAT + { D3D11_BLEND_BLEND_FACTOR, D3D11_BLEND_BLEND_FACTOR }, // FACTOR + { D3D11_BLEND_INV_BLEND_FACTOR, D3D11_BLEND_INV_BLEND_FACTOR }, // INV_FACTOR }; static const D3D11_BLEND_OP s_blendEquation[] = @@ -259,6 +261,10 @@ namespace bgfx { namespace d3d11 { DXGI_FORMAT_R32G32_SINT, DXGI_FORMAT_R32G32_SINT, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN }, // RG32I { DXGI_FORMAT_R32G32_UINT, DXGI_FORMAT_R32G32_UINT, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN }, // RG32U { DXGI_FORMAT_R32G32_FLOAT, DXGI_FORMAT_R32G32_FLOAT, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN }, // RG32F + { DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN }, // RGB8 + { DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN }, // RGB8I + { DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN }, // RGB8U + { DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN }, // RGB8S { DXGI_FORMAT_R9G9B9E5_SHAREDEXP, DXGI_FORMAT_R9G9B9E5_SHAREDEXP, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN }, // RGB9E5F { DXGI_FORMAT_B8G8R8A8_UNORM, DXGI_FORMAT_B8G8R8A8_UNORM, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_B8G8R8A8_UNORM_SRGB }, // BGRA8 { DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_R8G8B8A8_UNORM_SRGB }, // RGBA8 @@ -586,13 +592,14 @@ namespace bgfx { namespace d3d11 , m_currentDepthStencil(NULL) , m_captureTexture(NULL) , m_captureResolve(NULL) - , m_wireframe(false) , m_maxAnisotropy(1) , m_depthClamp(false) + , m_wireframe(false) , m_currentProgram(NULL) , m_vsChanges(0) , m_fsChanges(0) , m_rtMsaa(false) + , m_timerQuerySupport(false) , m_ovrRtv(NULL) , m_ovrDsv(NULL) { @@ -790,9 +797,12 @@ namespace bgfx { namespace d3d11 #if BX_PLATFORM_WINRT // WinRT requires the IDXGIFactory2 interface, which isn't supported on older platforms hr = CreateDXGIFactory1(__uuidof(IDXGIFactory2), (void**)&factory); -#else +#elif BX_PLATFORM_WINDOWS hr = CreateDXGIFactory(IID_IDXGIFactory, (void**)&factory); -#endif // BX_PLATFORM_WINRT +#else + hr = S_OK; + factory = NULL; +#endif // BX_PLATFORM_* BX_WARN(SUCCEEDED(hr), "Unable to create DXGI factory."); if (FAILED(hr) ) { @@ -811,60 +821,63 @@ namespace bgfx { namespace d3d11 : D3D_DRIVER_TYPE_HARDWARE ; - IDXGIAdapter* adapter; - for (uint32_t ii = 0 - ; DXGI_ERROR_NOT_FOUND != factory->EnumAdapters(ii, &adapter) && ii < BX_COUNTOF(g_caps.gpu) - ; ++ii - ) + if (NULL != factory) { - DXGI_ADAPTER_DESC desc; - hr = adapter->GetDesc(&desc); - if (SUCCEEDED(hr) ) + IDXGIAdapter* adapter; + for (uint32_t ii = 0 + ; DXGI_ERROR_NOT_FOUND != factory->EnumAdapters(ii, &adapter) && ii < BX_COUNTOF(g_caps.gpu) + ; ++ii + ) { - BX_TRACE("Adapter #%d", ii); - - char description[BX_COUNTOF(desc.Description)]; - wcstombs(description, desc.Description, BX_COUNTOF(desc.Description) ); - BX_TRACE("\tDescription: %s", description); - BX_TRACE("\tVendorId: 0x%08x, DeviceId: 0x%08x, SubSysId: 0x%08x, Revision: 0x%08x" - , desc.VendorId - , desc.DeviceId - , desc.SubSysId - , desc.Revision - ); - BX_TRACE("\tMemory: %" PRIi64 " (video), %" PRIi64 " (system), %" PRIi64 " (shared)" - , desc.DedicatedVideoMemory - , desc.DedicatedSystemMemory - , desc.SharedSystemMemory - ); + DXGI_ADAPTER_DESC desc; + hr = adapter->GetDesc(&desc); + if (SUCCEEDED(hr) ) + { + BX_TRACE("Adapter #%d", ii); + + char description[BX_COUNTOF(desc.Description)]; + wcstombs(description, desc.Description, BX_COUNTOF(desc.Description) ); + BX_TRACE("\tDescription: %s", description); + BX_TRACE("\tVendorId: 0x%08x, DeviceId: 0x%08x, SubSysId: 0x%08x, Revision: 0x%08x" + , desc.VendorId + , desc.DeviceId + , desc.SubSysId + , desc.Revision + ); + BX_TRACE("\tMemory: %" PRIi64 " (video), %" PRIi64 " (system), %" PRIi64 " (shared)" + , desc.DedicatedVideoMemory + , desc.DedicatedSystemMemory + , desc.SharedSystemMemory + ); - g_caps.gpu[ii].vendorId = (uint16_t)desc.VendorId; - g_caps.gpu[ii].deviceId = (uint16_t)desc.DeviceId; - ++g_caps.numGPUs; + g_caps.gpu[ii].vendorId = (uint16_t)desc.VendorId; + g_caps.gpu[ii].deviceId = (uint16_t)desc.DeviceId; + ++g_caps.numGPUs; - if (NULL == m_adapter) - { - if ( (BGFX_PCI_ID_NONE != g_caps.vendorId || 0 != g_caps.deviceId) - && (BGFX_PCI_ID_NONE == g_caps.vendorId || desc.VendorId == g_caps.vendorId) - && ( 0 == g_caps.deviceId || desc.DeviceId == g_caps.deviceId) ) + if (NULL == m_adapter) { - m_adapter = adapter; - m_adapter->AddRef(); - m_driverType = D3D_DRIVER_TYPE_UNKNOWN; - } + if ( (BGFX_PCI_ID_NONE != g_caps.vendorId || 0 != g_caps.deviceId) + && (BGFX_PCI_ID_NONE == g_caps.vendorId || desc.VendorId == g_caps.vendorId) + && ( 0 == g_caps.deviceId || desc.DeviceId == g_caps.deviceId) ) + { + m_adapter = adapter; + m_adapter->AddRef(); + m_driverType = D3D_DRIVER_TYPE_UNKNOWN; + } - if (BX_ENABLED(BGFX_CONFIG_DEBUG_PERFHUD) - && 0 != strstr(description, "PerfHUD") ) - { - m_adapter = adapter; - m_driverType = D3D_DRIVER_TYPE_REFERENCE; + if (BX_ENABLED(BGFX_CONFIG_DEBUG_PERFHUD) + && 0 != strstr(description, "PerfHUD") ) + { + m_adapter = adapter; + m_driverType = D3D_DRIVER_TYPE_REFERENCE; + } } } - } - DX_RELEASE(adapter, adapter == m_adapter ? 1 : 0); + DX_RELEASE(adapter, adapter == m_adapter ? 1 : 0); + } + DX_RELEASE(factory, NULL != m_adapter ? 1 : 0); } - DX_RELEASE(factory, NULL != m_adapter ? 1 : 0); D3D_FEATURE_LEVEL featureLevel[] = { @@ -1023,7 +1036,7 @@ BX_PRAGMA_DIAGNOSTIC_POP(); if (NULL == g_platformData.backBuffer) { -#if BX_PLATFORM_WINRT +#if !BX_PLATFORM_WINDOWS hr = adapter->GetParent(__uuidof(IDXGIFactory2), (void**)&m_factory); BX_WARN(SUCCEEDED(hr), "Unable to create Direct3D11 device."); DX_RELEASE(adapter, 2); @@ -1068,6 +1081,7 @@ BX_PRAGMA_DIAGNOSTIC_POP(); ); BX_WARN(SUCCEEDED(hr), "Unable to create Direct3D11 swap chain."); +# if BX_PLATFORM_WINRT IInspectable* nativeWindow = reinterpret_cast<IInspectable *>(g_platformData.nwh); ISwapChainBackgroundPanelNative* panel = NULL; hr = nativeWindow->QueryInterface(__uuidof(ISwapChainBackgroundPanelNative), (void**)&panel); @@ -1080,6 +1094,7 @@ BX_PRAGMA_DIAGNOSTIC_POP(); panel->Release(); } +# endif // BX_PLATFORM_WINRT } #else hr = adapter->GetParent(IID_IDXGIFactory, (void**)&m_factory); @@ -1112,7 +1127,7 @@ BX_PRAGMA_DIAGNOSTIC_POP(); | DXGI_MWA_NO_WINDOW_CHANGES | DXGI_MWA_NO_ALT_ENTER ) ); -#endif // BX_PLATFORM_WINRT +#endif // BX_PLATFORM_* BX_WARN(SUCCEEDED(hr), "Failed to create swap chain."); if (FAILED(hr) ) { @@ -1179,6 +1194,8 @@ BX_PRAGMA_DIAGNOSTIC_POP(); | BGFX_CAPS_OCCLUSION_QUERY ); + m_timerQuerySupport = m_featureLevel >= D3D_FEATURE_LEVEL_9_3; + if (m_featureLevel <= D3D_FEATURE_LEVEL_9_2) { g_caps.maxTextureSize = D3D_FL9_1_REQ_TEXTURE2D_U_OR_V_DIMENSION; @@ -2007,7 +2024,10 @@ BX_PRAGMA_DIAGNOSTIC_POP(); { ovrPreReset(); - m_gpuTimer.preReset(); + if (m_timerQuerySupport) + { + m_gpuTimer.preReset(); + } m_occlusionQuery.preReset(); if (NULL == g_platformData.backBufferDS) @@ -2052,7 +2072,10 @@ BX_PRAGMA_DIAGNOSTIC_POP(); DX_RELEASE(color, 0); } - m_gpuTimer.postReset(); + if (m_timerQuerySupport) + { + m_gpuTimer.postReset(); + } m_occlusionQuery.postReset(); ovrPostReset(); @@ -2106,7 +2129,7 @@ BX_PRAGMA_DIAGNOSTIC_POP(); if (NULL != m_swapChain) { HRESULT hr = S_OK; - uint32_t syncInterval = BX_ENABLED(BX_PLATFORM_WINRT) + uint32_t syncInterval = BX_ENABLED(!BX_PLATFORM_WINDOWS) ? 1 // sync interval of 0 is not supported on WinRT : !!(m_resolution.m_flags & BGFX_RESET_VSYNC) ; @@ -2222,7 +2245,7 @@ BX_PRAGMA_DIAGNOSTIC_POP(); flags &= ~BGFX_RESET_INTERNAL_FORCE; bool resize = true - && !BX_ENABLED(BX_PLATFORM_WINRT) // can't use ResizeBuffers on Windows Phone + && !BX_ENABLED(BX_PLATFORM_XBOXONE || BX_PLATFORM_WINRT) // can't use ResizeBuffers on Windows Phone && (m_resolution.m_flags&BGFX_RESET_MSAA_MASK) == (flags&BGFX_RESET_MSAA_MASK) ; @@ -2274,7 +2297,7 @@ BX_PRAGMA_DIAGNOSTIC_POP(); scd = &swapChainScd; } -#if BX_PLATFORM_WINRT +#if !BX_PLATFORM_WINDOWS HRESULT hr; if (g_platformData.ndt == 0) { @@ -2297,6 +2320,7 @@ BX_PRAGMA_DIAGNOSTIC_POP(); ); BGFX_FATAL(SUCCEEDED(hr), Fatal::UnableToInitialize, "Unable to create Direct3D11 swap chain."); +# if BX_PLATFORM_WINRT IInspectable *nativeWindow = reinterpret_cast<IInspectable *>(g_platformData.nwh); ISwapChainBackgroundPanelNative* panel = NULL; hr = nativeWindow->QueryInterface(__uuidof(ISwapChainBackgroundPanelNative), (void **)&panel); @@ -2309,6 +2333,7 @@ BX_PRAGMA_DIAGNOSTIC_POP(); panel->Release(); } +# endif // BX_PLATFORM_WINRT } #else HRESULT hr; @@ -2316,7 +2341,7 @@ BX_PRAGMA_DIAGNOSTIC_POP(); , scd , &m_swapChain ); -#endif // BX_PLATFORM_WINRT +#endif // !BX_PLATFORM_WINDOWS BGFX_FATAL(SUCCEEDED(hr), bgfx::Fatal::UnableToInitialize, "Failed to create swap chain."); } } @@ -2789,39 +2814,39 @@ BX_PRAGMA_DIAGNOSTIC_POP(); DXGI_FORMAT getBufferFormat() { -#if BX_PLATFORM_WINRT - return m_scd.Format; -#else +#if BX_PLATFORM_WINDOWS return m_scd.BufferDesc.Format; +#else + return m_scd.Format; #endif } uint32_t getBufferWidth() { -#if BX_PLATFORM_WINRT - return m_scd.Width; -#else +#if BX_PLATFORM_WINDOWS return m_scd.BufferDesc.Width; +#else + return m_scd.Width; #endif } uint32_t getBufferHeight() { -#if BX_PLATFORM_WINRT - return m_scd.Height; -#else +#if BX_PLATFORM_WINDOWS return m_scd.BufferDesc.Height; +#else + return m_scd.Height; #endif } void setBufferSize(uint32_t _width, uint32_t _height) { -#if BX_PLATFORM_WINRT - m_scd.Width = _width; - m_scd.Height = _height; -#else +#if BX_PLATFORM_WINDOWS m_scd.BufferDesc.Width = _width; m_scd.BufferDesc.Height = _height; +#else + m_scd.Width = _width; + m_scd.Height = _height; #endif } @@ -3348,13 +3373,13 @@ BX_PRAGMA_DIAGNOSTIC_POP(); D3D_FEATURE_LEVEL m_featureLevel; IDXGIAdapter* m_adapter; DXGI_ADAPTER_DESC m_adapterDesc; -#if BX_PLATFORM_WINRT - IDXGIFactory2* m_factory; - IDXGISwapChain1* m_swapChain; -#else +#if BX_PLATFORM_WINDOWS IDXGIFactory* m_factory; IDXGISwapChain* m_swapChain; -#endif // BX_PLATFORM_WINRT +#else + IDXGIFactory2* m_factory; + IDXGISwapChain1* m_swapChain; +#endif // BX_PLATFORM_WINDOWS uint16_t m_lost; uint16_t m_numWindows; @@ -3375,17 +3400,17 @@ BX_PRAGMA_DIAGNOSTIC_POP(); ID3D11Texture2D* m_captureResolve; Resolution m_resolution; - bool m_wireframe; -#if BX_PLATFORM_WINRT - typedef DXGI_SWAP_CHAIN_DESC1 SwapChainDesc; -#else +#if BX_PLATFORM_WINDOWS typedef DXGI_SWAP_CHAIN_DESC SwapChainDesc; -#endif // BX_PLATFORM_WINRT +#else + typedef DXGI_SWAP_CHAIN_DESC1 SwapChainDesc; +#endif // BX_PLATFORM_WINDOWS SwapChainDesc m_scd; uint32_t m_maxAnisotropy; bool m_depthClamp; + bool m_wireframe; IndexBufferD3D11 m_indexBuffers[BGFX_CONFIG_MAX_INDEX_BUFFERS]; VertexBufferD3D11 m_vertexBuffers[BGFX_CONFIG_MAX_VERTEX_BUFFERS]; @@ -3418,6 +3443,7 @@ BX_PRAGMA_DIAGNOSTIC_POP(); FrameBufferHandle m_fbh; bool m_rtMsaa; + bool m_timerQuerySupport; OVR m_ovr; TextureD3D11 m_ovrRT; @@ -3712,8 +3738,9 @@ BX_PRAGMA_DIAGNOSTIC_POP(); { bx::MemoryReader rd(_code, _size); + bx::Error err; DxbcContext dxbc; - read(&rd, dxbc); + read(&rd, dxbc, &err); struct FindDepthOp { @@ -3856,7 +3883,7 @@ BX_PRAGMA_DIAGNOSTIC_POP(); uint16_t shaderSize; bx::read(&reader, shaderSize); - const DWORD* code = (const DWORD*)reader.getDataPtr(); + const void* code = reader.getDataPtr(); bx::skip(&reader, shaderSize+1); if (BGFX_CHUNK_MAGIC_FSH == magic) @@ -3930,22 +3957,14 @@ BX_PRAGMA_DIAGNOSTIC_POP(); m_width = textureWidth; m_height = textureHeight; m_depth = imageContainer.m_depth; - m_requestedFormat = (uint8_t)imageContainer.m_format; - m_textureFormat = (uint8_t)imageContainer.m_format; - - const TextureFormatInfo& tfi = s_textureFormat[m_requestedFormat]; - const bool convert = DXGI_FORMAT_UNKNOWN == tfi.m_fmt; - - uint8_t bpp = getBitsPerPixel(TextureFormat::Enum(m_textureFormat) ); - if (convert) - { - m_textureFormat = (uint8_t)TextureFormat::BGRA8; - bpp = 32; - } + m_requestedFormat = uint8_t(imageContainer.m_format); + m_textureFormat = uint8_t(getViableTextureFormat(imageContainer) ); + const bool convert = m_textureFormat != m_requestedFormat; + const uint8_t bpp = getBitsPerPixel(TextureFormat::Enum(m_textureFormat) ); if (imageContainer.m_cubeMap) { - m_type = TextureCube; + m_type = TextureCube; } else if (imageContainer.m_depth > 1) { @@ -4056,7 +4075,7 @@ BX_PRAGMA_DIAGNOSTIC_POP(); if (format == DXGI_FORMAT_UNKNOWN) { // not swizzled and not sRGB, or sRGB unsupported - format = s_textureFormat[m_textureFormat].m_fmt; + format = s_textureFormat[m_textureFormat].m_fmt; srvd.Format = s_textureFormat[m_textureFormat].m_fmtSrv; } @@ -4717,7 +4736,10 @@ BX_PRAGMA_DIAGNOSTIC_POP(); int64_t elapsed = -bx::getHPCounter(); int64_t captureElapsed = 0; - m_gpuTimer.begin(); + if (m_timerQuerySupport) + { + m_gpuTimer.begin(); + } if (0 < _render->m_iboffset) { @@ -5627,15 +5649,18 @@ BX_PRAGMA_DIAGNOSTIC_POP(); static double maxGpuElapsed = 0.0f; double elapsedGpuMs = 0.0; - m_gpuTimer.end(); - - while (m_gpuTimer.get() ) + if (m_timerQuerySupport) { - double toGpuMs = 1000.0 / double(m_gpuTimer.m_frequency); - elapsedGpuMs = m_gpuTimer.m_elapsed * toGpuMs; - maxGpuElapsed = elapsedGpuMs > maxGpuElapsed ? elapsedGpuMs : maxGpuElapsed; + m_gpuTimer.end(); + + while (m_gpuTimer.get() ) + { + double toGpuMs = 1000.0 / double(m_gpuTimer.m_frequency); + elapsedGpuMs = m_gpuTimer.m_elapsed * toGpuMs; + maxGpuElapsed = elapsedGpuMs > maxGpuElapsed ? elapsedGpuMs : maxGpuElapsed; + } + maxGpuLatency = bx::uint32_imax(maxGpuLatency, m_gpuTimer.m_control.available()-1); } - maxGpuLatency = bx::uint32_imax(maxGpuLatency, m_gpuTimer.m_control.available()-1); const int64_t timerFreq = bx::getHPFrequency(); diff --git a/3rdparty/bgfx/src/renderer_d3d11.h b/3rdparty/bgfx/src/renderer_d3d11.h index 833eda40e1a..f4a92e4abb0 100644 --- a/3rdparty/bgfx/src/renderer_d3d11.h +++ b/3rdparty/bgfx/src/renderer_d3d11.h @@ -6,7 +6,7 @@ #ifndef BGFX_RENDERER_D3D11_H_HEADER_GUARD #define BGFX_RENDERER_D3D11_H_HEADER_GUARD -#define USE_D3D11_DYNAMIC_LIB !BX_PLATFORM_WINRT +#define USE_D3D11_DYNAMIC_LIB BX_PLATFORM_WINDOWS #if !USE_D3D11_DYNAMIC_LIB # undef BGFX_CONFIG_DEBUG_PIX @@ -19,11 +19,13 @@ BX_PRAGMA_DIAGNOSTIC_IGNORED_GCC("-Wpragmas"); BX_PRAGMA_DIAGNOSTIC_IGNORED_MSVC(4005) // warning C4005: '' : macro redefinition #include <sal.h> #define D3D11_NO_HELPERS -#if BX_PLATFORM_WINRT +#if BX_PLATFORM_WINDOWS +# include <d3d11.h> +#elif BX_PLATFORM_WINRT # include <d3d11_3.h> #else -# include <d3d11.h> -#endif // BX_PLATFORM_WINRT +# include <d3d11_x.h> +#endif // BX_PLATFORM_* BX_PRAGMA_DIAGNOSTIC_POP() #include "renderer.h" @@ -118,7 +120,6 @@ namespace bgfx { namespace d3d11 } void create(const Memory* _mem); - DWORD* getShaderCode(uint8_t _fragmentBit, const Memory* _mem); void destroy() { @@ -275,10 +276,11 @@ namespace bgfx { namespace d3d11 IDXGISwapChain* m_swapChain; uint32_t m_width; uint32_t m_height; + + Attachment m_attachment[BGFX_CONFIG_MAX_FRAME_BUFFER_ATTACHMENTS]; uint16_t m_denseIdx; uint8_t m_num; uint8_t m_numTh; - Attachment m_attachment[BGFX_CONFIG_MAX_FRAME_BUFFER_ATTACHMENTS]; }; struct TimerQueryD3D11 diff --git a/3rdparty/bgfx/src/renderer_d3d12.cpp b/3rdparty/bgfx/src/renderer_d3d12.cpp index 409d33bce10..06bc0632536 100644 --- a/3rdparty/bgfx/src/renderer_d3d12.cpp +++ b/3rdparty/bgfx/src/renderer_d3d12.cpp @@ -18,7 +18,7 @@ namespace bgfx { namespace d3d12 struct PrimInfo { - D3D_PRIMITIVE_TOPOLOGY m_toplogy; + D3D_PRIMITIVE_TOPOLOGY m_topology; D3D12_PRIMITIVE_TOPOLOGY_TYPE m_topologyType; uint32_t m_min; uint32_t m_div; @@ -63,20 +63,20 @@ namespace bgfx { namespace d3d12 static const D3D12_BLEND s_blendFactor[][2] = { - { (D3D12_BLEND)0, (D3D12_BLEND)0 }, // ignored + { D3D12_BLEND(0), D3D12_BLEND(0) }, // ignored { D3D12_BLEND_ZERO, D3D12_BLEND_ZERO }, // ZERO - { D3D12_BLEND_ONE, D3D12_BLEND_ONE }, // ONE - { D3D12_BLEND_SRC_COLOR, D3D12_BLEND_SRC_ALPHA }, // SRC_COLOR - { D3D12_BLEND_INV_SRC_COLOR, D3D12_BLEND_INV_SRC_ALPHA }, // INV_SRC_COLOR - { D3D12_BLEND_SRC_ALPHA, D3D12_BLEND_SRC_ALPHA }, // SRC_ALPHA - { D3D12_BLEND_INV_SRC_ALPHA, D3D12_BLEND_INV_SRC_ALPHA }, // INV_SRC_ALPHA - { D3D12_BLEND_DEST_ALPHA, D3D12_BLEND_DEST_ALPHA }, // DST_ALPHA - { D3D12_BLEND_INV_DEST_ALPHA, D3D12_BLEND_INV_DEST_ALPHA }, // INV_DST_ALPHA - { D3D12_BLEND_DEST_COLOR, D3D12_BLEND_DEST_ALPHA }, // DST_COLOR - { D3D12_BLEND_INV_DEST_COLOR, D3D12_BLEND_INV_DEST_ALPHA }, // INV_DST_COLOR - { D3D12_BLEND_SRC_ALPHA_SAT, D3D12_BLEND_ONE }, // SRC_ALPHA_SAT - { D3D12_BLEND_BLEND_FACTOR, D3D12_BLEND_BLEND_FACTOR }, // FACTOR - { D3D12_BLEND_INV_BLEND_FACTOR, D3D12_BLEND_INV_BLEND_FACTOR }, // INV_FACTOR + { D3D12_BLEND_ONE, D3D12_BLEND_ONE }, // ONE + { D3D12_BLEND_SRC_COLOR, D3D12_BLEND_SRC_ALPHA }, // SRC_COLOR + { D3D12_BLEND_INV_SRC_COLOR, D3D12_BLEND_INV_SRC_ALPHA }, // INV_SRC_COLOR + { D3D12_BLEND_SRC_ALPHA, D3D12_BLEND_SRC_ALPHA }, // SRC_ALPHA + { D3D12_BLEND_INV_SRC_ALPHA, D3D12_BLEND_INV_SRC_ALPHA }, // INV_SRC_ALPHA + { D3D12_BLEND_DEST_ALPHA, D3D12_BLEND_DEST_ALPHA }, // DST_ALPHA + { D3D12_BLEND_INV_DEST_ALPHA, D3D12_BLEND_INV_DEST_ALPHA }, // INV_DST_ALPHA + { D3D12_BLEND_DEST_COLOR, D3D12_BLEND_DEST_ALPHA }, // DST_COLOR + { D3D12_BLEND_INV_DEST_COLOR, D3D12_BLEND_INV_DEST_ALPHA }, // INV_DST_COLOR + { D3D12_BLEND_SRC_ALPHA_SAT, D3D12_BLEND_ONE }, // SRC_ALPHA_SAT + { D3D12_BLEND_BLEND_FACTOR, D3D12_BLEND_BLEND_FACTOR }, // FACTOR + { D3D12_BLEND_INV_BLEND_FACTOR, D3D12_BLEND_INV_BLEND_FACTOR }, // INV_FACTOR }; static const D3D12_BLEND_OP s_blendEquation[] = @@ -221,6 +221,10 @@ namespace bgfx { namespace d3d12 { DXGI_FORMAT_R32G32_SINT, DXGI_FORMAT_R32G32_SINT, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN }, // RG32I { DXGI_FORMAT_R32G32_UINT, DXGI_FORMAT_R32G32_UINT, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN }, // RG32U { DXGI_FORMAT_R32G32_FLOAT, DXGI_FORMAT_R32G32_FLOAT, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN }, // RG32F + { DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN }, // RGB8 + { DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN }, // RGB8I + { DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN }, // RGB8U + { DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN }, // RGB8S { DXGI_FORMAT_R9G9B9E5_SHAREDEXP, DXGI_FORMAT_R9G9B9E5_SHAREDEXP, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN }, // RGB9E5F { DXGI_FORMAT_B8G8R8A8_UNORM, DXGI_FORMAT_B8G8R8A8_UNORM, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_B8G8R8A8_UNORM_SRGB }, // BGRA8 { DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_R8G8B8A8_UNORM_SRGB }, // RGBA8 @@ -556,7 +560,12 @@ namespace bgfx { namespace d3d12 HRESULT hr; +#if BX_PLATFORM_WINDOWS hr = CreateDXGIFactory1(IID_IDXGIFactory4, (void**)&m_factory); +#else + hr = S_OK; + m_factory = NULL; +#endif // BX_PLATFORM_* BX_WARN(SUCCEEDED(hr), "Unable to create DXGI factory."); if (FAILED(hr) ) @@ -570,7 +579,11 @@ namespace bgfx { namespace d3d12 m_driverType = D3D_DRIVER_TYPE_HARDWARE; { +#if BX_PLATFORM_WINDOWS IDXGIAdapter3* adapter; +#else + IDXGIAdapter* adapter; +#endif // BX_PLATFORM_* for (uint32_t ii = 0; DXGI_ERROR_NOT_FOUND != m_factory->EnumAdapters(ii, reinterpret_cast<IDXGIAdapter**>(&adapter) ); ++ii) { DXGI_ADAPTER_DESC desc; @@ -663,7 +676,11 @@ namespace bgfx { namespace d3d12 { memset(&m_adapterDesc, 0, sizeof(m_adapterDesc) ); luid = m_device->GetAdapterLuid(); +#if BX_PLATFORM_WINDOWS IDXGIAdapter3* adapter; +#else + IDXGIAdapter* adapter; +#endif // BX_PLATFORM_* for (uint32_t ii = 0; DXGI_ERROR_NOT_FOUND != m_factory->EnumAdapters(ii, reinterpret_cast<IDXGIAdapter**>(&adapter) ); ++ii) { adapter->GetDesc(&m_adapterDesc); @@ -756,14 +773,15 @@ namespace bgfx { namespace d3d12 m_resolution.m_width = BGFX_DEFAULT_WIDTH; m_resolution.m_height = BGFX_DEFAULT_HEIGHT; + m_numWindows = 1; + +#if BX_PLATFORM_WINDOWS DX_CHECK(m_factory->MakeWindowAssociation( (HWND)g_platformData.nwh , 0 | DXGI_MWA_NO_WINDOW_CHANGES | DXGI_MWA_NO_ALT_ENTER ) ); - m_numWindows = 1; - if (BX_ENABLED(BGFX_CONFIG_DEBUG) ) { hr = m_device->QueryInterface(IID_ID3D12InfoQueue, (void**)&m_infoQueue); @@ -789,6 +807,7 @@ namespace bgfx { namespace d3d12 DX_RELEASE_WARNONLY(m_infoQueue, 0); } } +#endif // BX_PLATFORM_WINDOWS D3D12_DESCRIPTOR_HEAP_DESC rtvDescHeap; rtvDescHeap.NumDescriptors = 0 @@ -1772,6 +1791,8 @@ data.NumQualityLevels = 0; preReset(); + BX_UNUSED(resize); +#if BX_PLATFORM_WINDOWS if (resize) { uint32_t nodeMask[] = { 1, 1, 1, 1 }; @@ -1789,6 +1810,7 @@ data.NumQualityLevels = 0; ) ); } else +#endif // BX_PLATFORM_WINDOWS { updateMsaa(); m_scd.SampleDesc = s_msaa[(m_resolution.m_flags&BGFX_RESET_MSAA_MASK)>>BGFX_RESET_MSAA_SHIFT]; @@ -1943,13 +1965,14 @@ data.NumQualityLevels = 0; m_rtMsaa = _msaa; } - void setBlendState(D3D12_BLEND_DESC& desc, uint64_t _state, uint32_t _rgba = 0) + void setBlendState(D3D12_BLEND_DESC& _desc, uint64_t _state, uint32_t _rgba = 0) { - memset(&desc, 0, sizeof(desc) ); - desc.IndependentBlendEnable = !!(BGFX_STATE_BLEND_INDEPENDENT & _state); + _desc.AlphaToCoverageEnable = false; + _desc.IndependentBlendEnable = !!(BGFX_STATE_BLEND_INDEPENDENT & _state); - D3D12_RENDER_TARGET_BLEND_DESC* drt = &desc.RenderTarget[0]; - drt->BlendEnable = !!(BGFX_STATE_BLEND_MASK & _state); + D3D12_RENDER_TARGET_BLEND_DESC* drt = &_desc.RenderTarget[0]; + drt->BlendEnable = !!(BGFX_STATE_BLEND_MASK & _state); + drt->LogicOpEnable = false; { const uint32_t blend = uint32_t( (_state & BGFX_STATE_BLEND_MASK ) >> BGFX_STATE_BLEND_SHIFT); @@ -1983,14 +2006,16 @@ data.NumQualityLevels = 0; : 0 ; + drt->LogicOp = D3D12_LOGIC_OP_CLEAR; drt->RenderTargetWriteMask = writeMask; - if (desc.IndependentBlendEnable) + if (_desc.IndependentBlendEnable) { for (uint32_t ii = 1, rgba = _rgba; ii < BGFX_CONFIG_MAX_FRAME_BUFFER_ATTACHMENTS; ++ii, rgba >>= 11) { - drt = &desc.RenderTarget[ii]; + drt = &_desc.RenderTarget[ii]; drt->BlendEnable = 0 != (rgba & 0x7ff); + drt->LogicOpEnable = false; const uint32_t src = (rgba ) & 0xf; const uint32_t dst = (rgba >> 4) & 0xf; @@ -2004,6 +2029,7 @@ data.NumQualityLevels = 0; drt->DestBlendAlpha = s_blendFactor[dst][1]; drt->BlendOpAlpha = s_blendEquation[equation]; + drt->LogicOp = D3D12_LOGIC_OP_CLEAR; drt->RenderTargetWriteMask = writeMask; } } @@ -2011,61 +2037,61 @@ data.NumQualityLevels = 0; { for (uint32_t ii = 1; ii < BGFX_CONFIG_MAX_FRAME_BUFFER_ATTACHMENTS; ++ii) { - memcpy(&desc.RenderTarget[ii], drt, sizeof(D3D12_RENDER_TARGET_BLEND_DESC) ); + memcpy(&_desc.RenderTarget[ii], drt, sizeof(D3D12_RENDER_TARGET_BLEND_DESC) ); } } } - void setRasterizerState(D3D12_RASTERIZER_DESC& desc, uint64_t _state, bool _wireframe = false) + void setRasterizerState(D3D12_RASTERIZER_DESC& _desc, uint64_t _state, bool _wireframe = false) { const uint32_t cull = (_state&BGFX_STATE_CULL_MASK) >> BGFX_STATE_CULL_SHIFT; - desc.FillMode = _wireframe + _desc.FillMode = _wireframe ? D3D12_FILL_MODE_WIREFRAME : D3D12_FILL_MODE_SOLID ; - desc.CullMode = s_cullMode[cull]; - desc.FrontCounterClockwise = false; - desc.DepthBias = 0; - desc.DepthBiasClamp = 0.0f; - desc.SlopeScaledDepthBias = 0.0f; - desc.DepthClipEnable = !m_depthClamp; - desc.MultisampleEnable = !!(_state&BGFX_STATE_MSAA); - desc.AntialiasedLineEnable = false; - desc.ForcedSampleCount = 0; - desc.ConservativeRaster = D3D12_CONSERVATIVE_RASTERIZATION_MODE_OFF; + _desc.CullMode = s_cullMode[cull]; + _desc.FrontCounterClockwise = false; + _desc.DepthBias = 0; + _desc.DepthBiasClamp = 0.0f; + _desc.SlopeScaledDepthBias = 0.0f; + _desc.DepthClipEnable = !m_depthClamp; + _desc.MultisampleEnable = !!(_state&BGFX_STATE_MSAA); + _desc.AntialiasedLineEnable = false; + _desc.ForcedSampleCount = 0; + _desc.ConservativeRaster = D3D12_CONSERVATIVE_RASTERIZATION_MODE_OFF; } - void setDepthStencilState(D3D12_DEPTH_STENCIL_DESC& desc, uint64_t _state, uint64_t _stencil = 0) + void setDepthStencilState(D3D12_DEPTH_STENCIL_DESC& _desc, uint64_t _state, uint64_t _stencil = 0) { const uint32_t fstencil = unpackStencil(0, _stencil); - memset(&desc, 0, sizeof(desc) ); + memset(&_desc, 0, sizeof(_desc) ); uint32_t func = (_state&BGFX_STATE_DEPTH_TEST_MASK)>>BGFX_STATE_DEPTH_TEST_SHIFT; - desc.DepthEnable = 0 != func; - desc.DepthWriteMask = !!(BGFX_STATE_DEPTH_WRITE & _state) + _desc.DepthEnable = 0 != func; + _desc.DepthWriteMask = !!(BGFX_STATE_DEPTH_WRITE & _state) ? D3D12_DEPTH_WRITE_MASK_ALL : D3D12_DEPTH_WRITE_MASK_ZERO ; - desc.DepthFunc = s_cmpFunc[func]; + _desc.DepthFunc = s_cmpFunc[func]; uint32_t bstencil = unpackStencil(1, _stencil); uint32_t frontAndBack = bstencil != BGFX_STENCIL_NONE && bstencil != fstencil; bstencil = frontAndBack ? bstencil : fstencil; - desc.StencilEnable = 0 != _stencil; - desc.StencilReadMask = (fstencil & BGFX_STENCIL_FUNC_RMASK_MASK) >> BGFX_STENCIL_FUNC_RMASK_SHIFT; - desc.StencilWriteMask = 0xff; + _desc.StencilEnable = 0 != _stencil; + _desc.StencilReadMask = (fstencil & BGFX_STENCIL_FUNC_RMASK_MASK) >> BGFX_STENCIL_FUNC_RMASK_SHIFT; + _desc.StencilWriteMask = 0xff; - desc.FrontFace.StencilFailOp = s_stencilOp[(fstencil & BGFX_STENCIL_OP_FAIL_S_MASK) >> BGFX_STENCIL_OP_FAIL_S_SHIFT]; - desc.FrontFace.StencilDepthFailOp = s_stencilOp[(fstencil & BGFX_STENCIL_OP_FAIL_Z_MASK) >> BGFX_STENCIL_OP_FAIL_Z_SHIFT]; - desc.FrontFace.StencilPassOp = s_stencilOp[(fstencil & BGFX_STENCIL_OP_PASS_Z_MASK) >> BGFX_STENCIL_OP_PASS_Z_SHIFT]; - desc.FrontFace.StencilFunc = s_cmpFunc[(fstencil & BGFX_STENCIL_TEST_MASK) >> BGFX_STENCIL_TEST_SHIFT]; + _desc.FrontFace.StencilFailOp = s_stencilOp[(fstencil & BGFX_STENCIL_OP_FAIL_S_MASK) >> BGFX_STENCIL_OP_FAIL_S_SHIFT]; + _desc.FrontFace.StencilDepthFailOp = s_stencilOp[(fstencil & BGFX_STENCIL_OP_FAIL_Z_MASK) >> BGFX_STENCIL_OP_FAIL_Z_SHIFT]; + _desc.FrontFace.StencilPassOp = s_stencilOp[(fstencil & BGFX_STENCIL_OP_PASS_Z_MASK) >> BGFX_STENCIL_OP_PASS_Z_SHIFT]; + _desc.FrontFace.StencilFunc = s_cmpFunc[(fstencil & BGFX_STENCIL_TEST_MASK) >> BGFX_STENCIL_TEST_SHIFT]; - desc.BackFace.StencilFailOp = s_stencilOp[(bstencil & BGFX_STENCIL_OP_FAIL_S_MASK) >> BGFX_STENCIL_OP_FAIL_S_SHIFT]; - desc.BackFace.StencilDepthFailOp = s_stencilOp[(bstencil & BGFX_STENCIL_OP_FAIL_Z_MASK) >> BGFX_STENCIL_OP_FAIL_Z_SHIFT]; - desc.BackFace.StencilPassOp = s_stencilOp[(bstencil & BGFX_STENCIL_OP_PASS_Z_MASK) >> BGFX_STENCIL_OP_PASS_Z_SHIFT]; - desc.BackFace.StencilFunc = s_cmpFunc[(bstencil&BGFX_STENCIL_TEST_MASK) >> BGFX_STENCIL_TEST_SHIFT]; + _desc.BackFace.StencilFailOp = s_stencilOp[(bstencil & BGFX_STENCIL_OP_FAIL_S_MASK) >> BGFX_STENCIL_OP_FAIL_S_SHIFT]; + _desc.BackFace.StencilDepthFailOp = s_stencilOp[(bstencil & BGFX_STENCIL_OP_FAIL_Z_MASK) >> BGFX_STENCIL_OP_FAIL_Z_SHIFT]; + _desc.BackFace.StencilPassOp = s_stencilOp[(bstencil & BGFX_STENCIL_OP_PASS_Z_MASK) >> BGFX_STENCIL_OP_PASS_Z_SHIFT]; + _desc.BackFace.StencilFunc = s_cmpFunc[(bstencil&BGFX_STENCIL_TEST_MASK) >> BGFX_STENCIL_TEST_SHIFT]; } uint32_t setInputLayout(D3D12_INPUT_ELEMENT_DESC* _vertexElements, const VertexDecl& _vertexDecl, const ProgramD3D12& _program, uint8_t _numInstanceData) @@ -2230,7 +2256,8 @@ data.NumQualityLevels = 0; bx::StaticMemoryBlockWriter wr(temp->data, temp->size); DxbcContext dxbc; - read(&rd, dxbc); + bx::Error err; + read(&rd, dxbc, &err); bool patchShader = true; if (BX_ENABLED(BGFX_CONFIG_DEBUG) ) @@ -2238,7 +2265,7 @@ data.NumQualityLevels = 0; union { uint32_t offset; void* ptr; } cast = { 0 }; filter(dxbc.shader, dxbc.shader, patchCb0, cast.ptr); - write(&wr, dxbc); + write(&wr, dxbc, &err); dxbcHash(temp->data + 20, temp->size - 20, temp->data + 4); @@ -2272,7 +2299,7 @@ data.NumQualityLevels = 0; uint32_t(program.m_vsh->m_size)/16 }; filter(dxbc.shader, dxbc.shader, patchCb0, cast.ptr); - write(&wr, dxbc); + write(&wr, dxbc, &err); dxbcHash(temp->data + 20, temp->size - 20, temp->data + 4); desc.PS.pShaderBytecode = temp->data; @@ -2616,21 +2643,27 @@ data.NumQualityLevels = 0; void* m_dxgidll; D3D_DRIVER_TYPE m_driverType; - IDXGIAdapter3* m_adapter; DXGI_ADAPTER_DESC m_adapterDesc; D3D12_FEATURE_DATA_ARCHITECTURE m_architecture; D3D12_FEATURE_DATA_D3D12_OPTIONS m_options; - IDXGIFactory4* m_factory; - +#if BX_PLATFORM_WINDOWS + IDXGIAdapter3* m_adapter; + IDXGIFactory4* m_factory; IDXGISwapChain3* m_swapChain; + ID3D12InfoQueue* m_infoQueue; +#else + IDXGIAdapter* m_adapter; + IDXGIFactory2* m_factory; + IDXGISwapChain1* m_swapChain; +#endif // BX_PLATFORM_WINDOWS + int64_t m_presentElapsed; uint16_t m_lost; uint16_t m_numWindows; FrameBufferHandle m_windows[BGFX_CONFIG_MAX_FRAME_BUFFERS]; ID3D12Device* m_device; - ID3D12InfoQueue* m_infoQueue; TimerQueryD3D12 m_gpuTimer; OcclusionQueryD3D12 m_occlusionQuery; @@ -3718,7 +3751,7 @@ data.NumQualityLevels = 0; uint16_t shaderSize; bx::read(&reader, shaderSize); - const DWORD* code = (const DWORD*)reader.getDataPtr(); + const void* code = reader.getDataPtr(); bx::skip(&reader, shaderSize+1); m_code = copy(code, shaderSize); @@ -3769,18 +3802,10 @@ data.NumQualityLevels = 0; m_width = textureWidth; m_height = textureHeight; m_depth = imageContainer.m_depth; - m_requestedFormat = (uint8_t)imageContainer.m_format; - m_textureFormat = (uint8_t)imageContainer.m_format; - - const TextureFormatInfo& tfi = s_textureFormat[m_requestedFormat]; - const bool convert = DXGI_FORMAT_UNKNOWN == tfi.m_fmt; - - uint8_t bpp = getBitsPerPixel(TextureFormat::Enum(m_textureFormat) ); - if (convert) - { - m_textureFormat = (uint8_t)TextureFormat::BGRA8; - bpp = 32; - } + m_requestedFormat = uint8_t(imageContainer.m_format); + m_textureFormat = uint8_t(getViableTextureFormat(imageContainer) ); + const bool convert = m_textureFormat != m_requestedFormat; + const uint8_t bpp = getBitsPerPixel(TextureFormat::Enum(m_textureFormat) ); if (imageContainer.m_cubeMap) { @@ -4578,7 +4603,9 @@ data.NumQualityLevels = 0; uint32_t statsNumIndices = 0; uint32_t statsKeyType[2] = {}; +#if BX_PLATFORM_WINDOWS m_backBufferColorIdx = m_swapChain->GetCurrentBackBufferIndex(); +#endif // BX_PLATFORM_WINDOWS const uint64_t f0 = BGFX_STATE_BLEND_FUNC(BGFX_STATE_BLEND_FACTOR, BGFX_STATE_BLEND_FACTOR); const uint64_t f1 = BGFX_STATE_BLEND_FUNC(BGFX_STATE_BLEND_INV_FACTOR, BGFX_STATE_BLEND_INV_FACTOR); @@ -4992,7 +5019,7 @@ data.NumQualityLevels = 0; || 0 != changedStencil || (hasFactor && blendFactor != draw.m_rgba) || (0 != (BGFX_STATE_PT_MASK & changedFlags) - || prim.m_toplogy != s_primInfo[primIndex].m_toplogy) + || prim.m_topology != s_primInfo[primIndex].m_topology) || currentState.m_scissor != scissor || pso != currentPso || hasOcclusionQuery) @@ -5083,12 +5110,12 @@ data.NumQualityLevels = 0; } if (0 != (BGFX_STATE_PT_MASK & changedFlags) - || prim.m_toplogy != s_primInfo[primIndex].m_toplogy) + || prim.m_topology != s_primInfo[primIndex].m_topology) { const uint64_t pt = newFlags&BGFX_STATE_PT_MASK; primIndex = uint8_t(pt>>BGFX_STATE_PT_SHIFT); prim = s_primInfo[primIndex]; - m_commandList->IASetPrimitiveTopology(prim.m_toplogy); + m_commandList->IASetPrimitiveTopology(prim.m_topology); } if (currentState.m_scissor != scissor) @@ -5272,6 +5299,7 @@ data.NumQualityLevels = 0; , processMemoryUsed ); +#if BX_PLATFORM_WINDOWS DXGI_QUERY_VIDEO_MEMORY_INFO memInfo; DX_CHECK(m_adapter->QueryVideoMemoryInfo(0, DXGI_MEMORY_SEGMENT_GROUP_LOCAL, &memInfo) ); @@ -5293,6 +5321,7 @@ data.NumQualityLevels = 0; , availableForReservation , currentReservation ); +#endif // BX_PLATFORM_WINDOWS pos = 10; tvm.printf(10, pos++, 0x8e, " Frame: % 7.3f, % 7.3f \x1f, % 7.3f \x1e [ms] / % 6.2f FPS " diff --git a/3rdparty/bgfx/src/renderer_d3d12.h b/3rdparty/bgfx/src/renderer_d3d12.h index 39f165a03da..e78e0c52b62 100644 --- a/3rdparty/bgfx/src/renderer_d3d12.h +++ b/3rdparty/bgfx/src/renderer_d3d12.h @@ -6,10 +6,14 @@ #ifndef BGFX_RENDERER_D3D12_H_HEADER_GUARD #define BGFX_RENDERER_D3D12_H_HEADER_GUARD -#define USE_D3D12_DYNAMIC_LIB 1 +#define USE_D3D12_DYNAMIC_LIB BX_PLATFORM_WINDOWS #include <sal.h> -#include <d3d12.h> +#if BX_PLATFORM_XBOXONE +# include <d3d12_x.h> +#else +# include <d3d12.h> +#endif // BX_PLATFORM_XBOXONE #if defined(__MINGW32__) // BK - temp workaround for MinGW until I nuke d3dx12 usage. extern "C++" { @@ -27,10 +31,20 @@ extern "C++" { BX_PRAGMA_DIAGNOSTIC_PUSH(); BX_PRAGMA_DIAGNOSTIC_IGNORED_CLANG_GCC("-Wmissing-field-initializers"); -#include <d3dx12.h> +#if BX_PLATFORM_XBOXONE +# include <d3dx12_x.h> +#else +# include <d3dx12.h> +#endif // BX_PLATFORM_XBOXONE BX_PRAGMA_DIAGNOSTIC_POP(); -#include <dxgi1_4.h> +#if BX_PLATFORM_WINDOWS +# include <dxgi1_4.h> +#endif // BX_PLATFORM_WINDOWS + +#ifndef D3D12_TEXTURE_DATA_PITCH_ALIGNMENT +# define D3D12_TEXTURE_DATA_PITCH_ALIGNMENT 1024 +#endif // D3D12_TEXTURE_DATA_PITCH_ALIGNMENT #include "renderer.h" #include "renderer_d3d.h" @@ -173,7 +187,6 @@ namespace bgfx { namespace d3d12 } void create(const Memory* _mem); - DWORD* getShaderCode(uint8_t _fragmentBit, const Memory* _mem); void destroy() { diff --git a/3rdparty/bgfx/src/renderer_d3d9.cpp b/3rdparty/bgfx/src/renderer_d3d9.cpp index 919a952260b..8b52ff2d6b6 100644 --- a/3rdparty/bgfx/src/renderer_d3d9.cpp +++ b/3rdparty/bgfx/src/renderer_d3d9.cpp @@ -215,6 +215,10 @@ namespace bgfx { namespace d3d9 { D3DFMT_UNKNOWN }, // RG32I { D3DFMT_UNKNOWN }, // RG32U { D3DFMT_G32R32F }, // RG32F + { D3DFMT_UNKNOWN }, // RGB8 + { D3DFMT_UNKNOWN }, // RGB8I + { D3DFMT_UNKNOWN }, // RGB8U + { D3DFMT_UNKNOWN }, // RGB8S { D3DFMT_UNKNOWN }, // RGB9E5F { D3DFMT_A8R8G8B8 }, // BGRA8 { D3DFMT_UNKNOWN }, // RGBA8 @@ -340,10 +344,10 @@ namespace bgfx { namespace d3d9 m_params.BackBufferHeight = rect.bottom-rect.top; m_d3d9dll = bx::dlopen("d3d9.dll"); - BX_WARN(NULL != m_d3d9dll, "Failed to load d3d9.dll."); if (NULL == m_d3d9dll) { + BX_TRACE("Failed to load d3d9.dll."); goto error; } @@ -370,16 +374,25 @@ namespace bgfx { namespace d3d9 && NULL != Direct3DCreate9Ex) { Direct3DCreate9Ex(D3D_SDK_VERSION, &m_d3d9ex); - DX_CHECK(m_d3d9ex->QueryInterface(IID_IDirect3D9, (void**)&m_d3d9) ); - m_pool = D3DPOOL_DEFAULT; + HRESULT hr = m_d3d9ex->QueryInterface(IID_IDirect3D9, (void**)&m_d3d9); + if (FAILED(hr) ) + { + BX_TRACE("Failed to query D3D9 interface 0x%08x.", hr); + DX_RELEASE(m_d3d9ex, 0); + } + else + { + m_pool = D3DPOOL_DEFAULT; + } } - else + + if (NULL == m_d3d9) { Direct3DCreate9 = (Direct3DCreate9Fn)bx::dlsym(m_d3d9dll, "Direct3DCreate9"); - BX_WARN(NULL != Direct3DCreate9, "Function Direct3DCreate9 not found."); if (NULL == Direct3DCreate9) { + BX_TRACE("Function Direct3DCreate9 not found."); goto error; } @@ -387,10 +400,9 @@ namespace bgfx { namespace d3d9 m_pool = D3DPOOL_MANAGED; } - BX_WARN(NULL != m_d3d9, "Unable to create Direct3D."); - if (NULL == m_d3d9) { + BX_TRACE("Unable to create Direct3D."); goto error; } @@ -487,10 +499,9 @@ namespace bgfx { namespace d3d9 } } - BX_WARN(NULL != m_device, "Unable to create Direct3D9 device."); - if (NULL == m_device) { + BX_TRACE("Unable to create Direct3D9 device."); goto error; } @@ -1317,21 +1328,30 @@ namespace bgfx { namespace d3d9 // If frame buffer has only depth attachment D3DFMT_NULL // render target is created. - uint32_t fbnum = bx::uint32_max(1, frameBuffer.m_num); + const uint32_t fbnum = bx::uint32_max(2, frameBuffer.m_numTh); + const uint8_t dsIdx = frameBuffer.m_dsIdx; + DX_CHECK(m_device->SetDepthStencilSurface(UINT8_MAX == dsIdx + ? m_backBufferDepthStencil + : frameBuffer.m_surface[dsIdx] + ) ); + + uint32_t rtIdx = 0; for (uint32_t ii = 0; ii < fbnum; ++ii) { - DX_CHECK(m_device->SetRenderTarget(ii, frameBuffer.m_color[ii]) ); + IDirect3DSurface9* surface = frameBuffer.m_surface[ii]; + if (ii != dsIdx) + { + DX_CHECK(m_device->SetRenderTarget(rtIdx, surface) ); + ++rtIdx; + } } - for (uint32_t ii = fbnum, num = g_caps.maxFBAttachments; ii < num; ++ii) + for (uint32_t ii = rtIdx, num = g_caps.maxFBAttachments; ii < num; ++ii) { DX_CHECK(m_device->SetRenderTarget(ii, NULL) ); } - IDirect3DSurface9* depthStencil = frameBuffer.m_depthStencil; - DX_CHECK(m_device->SetDepthStencilSurface(NULL != depthStencil ? depthStencil : m_backBufferDepthStencil) ); - DX_CHECK(m_device->SetRenderState(D3DRS_SRGBWRITEENABLE, FALSE) ); } @@ -2819,16 +2839,11 @@ namespace bgfx { namespace d3d9 m_height = textureHeight; m_depth = imageContainer.m_depth; m_numMips = numMips; - m_requestedFormat = - m_textureFormat = uint8_t(imageContainer.m_format); + m_requestedFormat = uint8_t(imageContainer.m_format); + m_textureFormat = uint8_t(getViableTextureFormat(imageContainer) ); + const bool convert = m_textureFormat != m_requestedFormat; - const TextureFormatInfo& tfi = s_textureFormat[m_requestedFormat]; uint8_t bpp = getBitsPerPixel(TextureFormat::Enum(m_textureFormat) ); - if (D3DFMT_UNKNOWN == tfi.m_fmt) - { - m_textureFormat = (uint8_t)TextureFormat::BGRA8; - bpp = 32; - } if (imageContainer.m_cubeMap) { @@ -2871,8 +2886,6 @@ namespace bgfx { namespace d3d9 && imageContainer.m_format != TextureFormat::BC5 ; - const bool convert = m_textureFormat != m_requestedFormat; - for (uint8_t side = 0, numSides = imageContainer.m_cubeMap ? 6 : 1; side < numSides; ++side) { uint32_t width = textureWidth; @@ -2925,7 +2938,20 @@ namespace bgfx { namespace d3d9 else { uint32_t size = useMipSize ? mip.m_size : mipSize; - memcpy(bits, mip.m_data, size); + switch (m_textureFormat) + { + case TextureFormat::RGB5A1: + imageConvert(bits, 16, packBgr5a1, mip.m_data, unpackRgb5a1, size); + break; + + case TextureFormat::RGBA4: + imageConvert(bits, 16, packBgra4, mip.m_data, unpackRgba4, size); + break; + + default: + memcpy(bits, mip.m_data, size); + break; + } } unlock(side, lod); @@ -2974,7 +3000,20 @@ namespace bgfx { namespace d3d9 uint8_t* dst = bits; for (uint32_t yy = 0, height = _rect.m_height; yy < height; ++yy) { - memcpy(dst, src, rectpitch); + switch (m_textureFormat) + { + case TextureFormat::RGB5A1: + imageConvert(dst, 16, packBgr5a1, src, unpackRgb5a1, rectpitch); + break; + + case TextureFormat::RGBA4: + imageConvert(dst, 16, packBgra4, src, unpackRgba4, rectpitch); + break; + + default: + memcpy(dst, src, rectpitch); + break; + } src += srcpitch; dst += dstpitch; } @@ -3064,50 +3103,53 @@ namespace bgfx { namespace d3d9 void FrameBufferD3D9::create(uint8_t _num, const Attachment* _attachment) { - for (uint32_t ii = 0; ii < BX_COUNTOF(m_color); ++ii) + for (uint32_t ii = 0; ii < BX_COUNTOF(m_surface); ++ii) { - m_color[ii] = NULL; + m_surface[ii] = NULL; } - m_depthStencil = NULL; - m_num = 0; + m_dsIdx = UINT8_MAX; + m_num = 0; + m_numTh = _num; m_needResolve = false; + memcpy(m_attachment, _attachment, _num*sizeof(Attachment) ); + for (uint32_t ii = 0; ii < _num; ++ii) { - TextureHandle handle = _attachment[ii].handle; + TextureHandle handle = m_attachment[ii].handle; if (isValid(handle) ) { const TextureD3D9& texture = s_renderD3D9->m_textures[handle.idx]; + if (NULL != texture.m_surface) + { + m_surface[ii] = texture.m_surface; + m_surface[ii]->AddRef(); + } + else + { + m_surface[ii] = texture.getSurface(uint8_t(m_attachment[ii].layer), uint8_t(m_attachment[ii].mip) ); + } + + if (0 == m_num) + { + m_width = texture.m_width; + m_height = texture.m_height; + } + if (isDepth( (TextureFormat::Enum)texture.m_textureFormat) ) { - m_depthHandle = handle; - if (NULL != texture.m_surface) - { - m_depthStencil = texture.m_surface; - m_depthStencil->AddRef(); - } - else - { - m_depthStencil = texture.getSurface(); - } + m_dsIdx = uint8_t(ii); } else { - m_colorHandle[m_num] = handle; - if (NULL != texture.m_surface) - { - m_color[m_num] = texture.m_surface; - m_color[m_num]->AddRef(); - } - else - { - m_color[m_num] = texture.getSurface(uint8_t(_attachment[ii].layer) ); - } - m_num++; + ++m_num; } - m_needResolve |= (NULL != texture.m_surface) && (NULL != texture.m_texture2d); + m_needResolve |= true + && (NULL != texture.m_surface) + && (NULL != texture.m_texture2d) + ; } } @@ -3132,7 +3174,7 @@ namespace bgfx { namespace d3d9 params.BackBufferHeight = m_height; DX_CHECK(s_renderD3D9->m_device->CreateAdditionalSwapChain(¶ms, &m_swapChain) ); - DX_CHECK(m_swapChain->GetBackBuffer(0, D3DBACKBUFFER_TYPE_MONO, &m_color[0]) ); + DX_CHECK(m_swapChain->GetBackBuffer(0, D3DBACKBUFFER_TYPE_MONO, &m_surface[0]) ); DX_CHECK(s_renderD3D9->m_device->CreateDepthStencilSurface( params.BackBufferWidth @@ -3141,11 +3183,11 @@ namespace bgfx { namespace d3d9 , params.MultiSampleType , params.MultiSampleQuality , FALSE - , &m_depthStencil + , &m_surface[1] , NULL ) ); - m_colorHandle[0].idx = invalidHandle; + m_dsIdx = 1; m_denseIdx = _denseIdx; m_num = 1; m_needResolve = false; @@ -3155,44 +3197,29 @@ namespace bgfx { namespace d3d9 { if (NULL != m_hwnd) { - DX_RELEASE(m_depthStencil, 0); - DX_RELEASE(m_color[0], 0); - DX_RELEASE(m_swapChain, 0); + DX_RELEASE(m_surface[0], 0); + DX_RELEASE(m_surface[1], 0); + DX_RELEASE(m_swapChain, 0); } else { - for (uint32_t ii = 0, num = m_num; ii < num; ++ii) - { - m_colorHandle[ii].idx = invalidHandle; + uint32_t num = m_numTh; + num += uint32_t(0 < m_numTh && 0 == m_num); - IDirect3DSurface9* ptr = m_color[ii]; + for (uint32_t ii = 0; ii < num; ++ii) + { + IDirect3DSurface9* ptr = m_surface[ii]; if (NULL != ptr) { ptr->Release(); - m_color[ii] = NULL; + m_surface[ii] = NULL; } } - - if (NULL != m_depthStencil) - { - if (0 == m_num) - { - IDirect3DSurface9* ptr = m_color[0]; - if (NULL != ptr) - { - ptr->Release(); - m_color[0] = NULL; - } - } - - m_depthStencil->Release(); - m_depthStencil = NULL; - } } - m_hwnd = NULL; - m_num = 0; - m_depthHandle.idx = invalidHandle; + m_hwnd = NULL; + m_num = 0; + m_numTh = 0; uint16_t denseIdx = m_denseIdx; m_denseIdx = UINT16_MAX; @@ -3209,15 +3236,9 @@ namespace bgfx { namespace d3d9 { if (m_needResolve) { - if (isValid(m_depthHandle) ) - { - const TextureD3D9& texture = s_renderD3D9->m_textures[m_depthHandle.idx]; - texture.resolve(); - } - - for (uint32_t ii = 0, num = m_num; ii < num; ++ii) + for (uint32_t ii = 0, num = m_numTh; ii < num; ++ii) { - const TextureD3D9& texture = s_renderD3D9->m_textures[m_colorHandle[ii].idx]; + const TextureD3D9& texture = s_renderD3D9->m_textures[m_attachment[ii].handle.idx]; texture.resolve(); } } @@ -3227,28 +3248,19 @@ namespace bgfx { namespace d3d9 { if (NULL != m_hwnd) { - DX_RELEASE(m_color[0], 0); - DX_RELEASE(m_depthStencil, 0); + DX_RELEASE(m_surface[0], 0); + DX_RELEASE(m_surface[1], 0); DX_RELEASE(m_swapChain, 0); } else { - for (uint32_t ii = 0, num = m_num; ii < num; ++ii) - { - m_color[ii]->Release(); - m_color[ii] = NULL; - } + uint32_t num = m_numTh; + num += uint32_t(0 < m_numTh && 0 == m_num); - if (isValid(m_depthHandle) ) + for (uint32_t ii = 0; ii < num; ++ii) { - if (0 == m_num) - { - m_color[0]->Release(); - m_color[0] = NULL; - } - - m_depthStencil->Release(); - m_depthStencil = NULL; + m_surface[ii]->Release(); + m_surface[ii] = NULL; } } } @@ -3263,69 +3275,55 @@ namespace bgfx { namespace d3d9 params.BackBufferHeight = m_height; DX_CHECK(s_renderD3D9->m_device->CreateAdditionalSwapChain(¶ms, &m_swapChain) ); - DX_CHECK(m_swapChain->GetBackBuffer(0, D3DBACKBUFFER_TYPE_MONO, &m_color[0]) ); + DX_CHECK(m_swapChain->GetBackBuffer(0, D3DBACKBUFFER_TYPE_MONO, &m_surface[0]) ); DX_CHECK(s_renderD3D9->m_device->CreateDepthStencilSurface(params.BackBufferWidth , params.BackBufferHeight , params.AutoDepthStencilFormat , params.MultiSampleType , params.MultiSampleQuality , FALSE - , &m_depthStencil + , &m_surface[1] , NULL ) ); } - else + else if (0 < m_numTh) { - for (uint32_t ii = 0, num = m_num; ii < num; ++ii) + for (uint32_t ii = 0, num = m_numTh; ii < num; ++ii) { - TextureHandle th = m_colorHandle[ii]; + TextureHandle th = m_attachment[ii].handle; if (isValid(th) ) { TextureD3D9& texture = s_renderD3D9->m_textures[th.idx]; if (NULL != texture.m_surface) { - m_color[ii] = texture.m_surface; - m_color[ii]->AddRef(); + m_surface[ii] = texture.m_surface; + m_surface[ii]->AddRef(); } else { - m_color[ii] = texture.getSurface(); + m_surface[ii] = texture.getSurface(uint8_t(m_attachment[ii].layer), uint8_t(m_attachment[ii].mip) ); } } } - if (isValid(m_depthHandle) ) + if (0 == m_num) { - TextureD3D9& texture = s_renderD3D9->m_textures[m_depthHandle.idx]; - if (NULL != texture.m_surface) - { - m_depthStencil = texture.m_surface; - m_depthStencil->AddRef(); - } - else - { - m_depthStencil = texture.getSurface(); - } - - if (0 == m_num) - { - createNullColorRT(); - } + createNullColorRT(); } } } void FrameBufferD3D9::createNullColorRT() { - const TextureD3D9& texture = s_renderD3D9->m_textures[m_depthHandle.idx]; - DX_CHECK(s_renderD3D9->m_device->CreateRenderTarget(texture.m_width - , texture.m_height + DX_CHECK(s_renderD3D9->m_device->CreateRenderTarget( + m_width + , m_height , D3DFMT_NULL , D3DMULTISAMPLE_NONE , 0 , false - , &m_color[0] + , &m_surface[1] , NULL ) ); } diff --git a/3rdparty/bgfx/src/renderer_d3d9.h b/3rdparty/bgfx/src/renderer_d3d9.h index 0b0e030dc5c..e93022ae660 100644 --- a/3rdparty/bgfx/src/renderer_d3d9.h +++ b/3rdparty/bgfx/src/renderer_d3d9.h @@ -236,7 +236,6 @@ namespace bgfx { namespace d3d9 } void create(const Memory* _mem); - DWORD* getShaderCode(uint8_t _fragmentBit, const Memory* _mem); void destroy() { @@ -383,10 +382,11 @@ namespace bgfx { namespace d3d9 FrameBufferD3D9() : m_hwnd(NULL) , m_denseIdx(UINT16_MAX) - , m_num(0) , m_needResolve(0) + , m_num(0) + , m_numTh(0) + , m_dsIdx(UINT8_MAX) { - m_depthHandle.idx = invalidHandle; } void create(uint8_t _num, const Attachment* _attachment); @@ -398,18 +398,18 @@ namespace bgfx { namespace d3d9 void postReset(); void createNullColorRT(); - IDirect3DSurface9* m_color[BGFX_CONFIG_MAX_FRAME_BUFFER_ATTACHMENTS-1]; - IDirect3DSurface9* m_depthStencil; + IDirect3DSurface9* m_surface[BGFX_CONFIG_MAX_FRAME_BUFFER_ATTACHMENTS-1]; IDirect3DSwapChain9* m_swapChain; HWND m_hwnd; uint32_t m_width; uint32_t m_height; - TextureHandle m_colorHandle[BGFX_CONFIG_MAX_FRAME_BUFFER_ATTACHMENTS-1]; - TextureHandle m_depthHandle; + Attachment m_attachment[BGFX_CONFIG_MAX_FRAME_BUFFER_ATTACHMENTS]; uint16_t m_denseIdx; - uint8_t m_num; bool m_needResolve; + uint8_t m_num; + uint8_t m_numTh; + uint8_t m_dsIdx; }; struct TimerQueryD3D9 diff --git a/3rdparty/bgfx/src/renderer_gl.cpp b/3rdparty/bgfx/src/renderer_gl.cpp index 0feccaf9680..7fc65a3dbd8 100644 --- a/3rdparty/bgfx/src/renderer_gl.cpp +++ b/3rdparty/bgfx/src/renderer_gl.cpp @@ -246,6 +246,10 @@ namespace bgfx { namespace gl { GL_RG32I, GL_ZERO, GL_RG, GL_INT, false }, // RG32I { GL_RG32UI, GL_ZERO, GL_RG, GL_UNSIGNED_INT, false }, // RG32U { GL_RG32F, GL_ZERO, GL_RG, GL_FLOAT, false }, // RG32F + { GL_RGB8, GL_SRGB8, GL_RGB, GL_UNSIGNED_BYTE, false }, // RGB8 + { GL_RGB8I, GL_ZERO, GL_RGB, GL_BYTE, false }, // RGB8I + { GL_RGB8UI, GL_ZERO, GL_RGB, GL_UNSIGNED_BYTE, false }, // RGB8U + { GL_RGB8_SNORM, GL_ZERO, GL_RGB, GL_BYTE, false }, // RGB8S { GL_RGB9_E5, GL_ZERO, GL_RGB, GL_UNSIGNED_INT_5_9_9_9_REV, false }, // RGB9E5F { GL_RGBA8, GL_SRGB8_ALPHA8, GL_BGRA, GL_UNSIGNED_BYTE, false }, // BGRA8 { GL_RGBA8, GL_SRGB8_ALPHA8, GL_RGBA, GL_UNSIGNED_BYTE, false }, // RGBA8 @@ -260,7 +264,7 @@ namespace bgfx { namespace gl { GL_RGBA32I, GL_ZERO, GL_RGBA, GL_INT, false }, // RGBA32I { GL_RGBA32UI, GL_ZERO, GL_RGBA, GL_UNSIGNED_INT, false }, // RGBA32U { GL_RGBA32F, GL_ZERO, GL_RGBA, GL_FLOAT, false }, // RGBA32F - { GL_RGB565, GL_ZERO, GL_RGB, GL_UNSIGNED_SHORT_5_6_5_REV, false }, // R5G6B5 + { GL_RGB565, GL_ZERO, GL_RGB, GL_UNSIGNED_SHORT_5_6_5, false }, // R5G6B5 { GL_RGBA4, GL_ZERO, GL_RGBA, GL_UNSIGNED_SHORT_4_4_4_4_REV, false }, // RGBA4 { GL_RGB5_A1, GL_ZERO, GL_RGBA, GL_UNSIGNED_SHORT_1_5_5_5_REV, false }, // RGB5A1 { GL_RGB10_A2, GL_ZERO, GL_RGBA, GL_UNSIGNED_INT_2_10_10_10_REV, false }, // RGB10A2 @@ -325,6 +329,10 @@ namespace bgfx { namespace gl GL_RG32I, // RG32I GL_RG32UI, // RG32U GL_RG32F, // RG32F + GL_RGB8, // RGB8 + GL_RGB8I, // RGB8I + GL_RGB8UI, // RGB8UI + GL_RGB8_SNORM, // RGB8S GL_RGB9_E5, // RGB9E5F GL_RGBA8, // BGRA8 GL_RGBA8, // RGBA8 @@ -402,6 +410,10 @@ namespace bgfx { namespace gl GL_RG32I, // RG32I GL_RG32UI, // RG32U GL_RG32F, // RG32F + GL_RGB8, // RGB8 + GL_RGB8I, // RGB8I + GL_RGB8UI, // RGB8UI + GL_RGB8_SNORM, // RGB8S GL_RGB9_E5, // RGB9E5F GL_RGBA8, // BGRA8 GL_RGBA8, // RGBA8 @@ -1551,6 +1563,8 @@ namespace bgfx { namespace gl if (BX_ENABLED(BGFX_CONFIG_RENDERER_OPENGL) || BX_ENABLED(BGFX_CONFIG_RENDERER_OPENGLES >= 30) ) { + setTextureFormat(TextureFormat::R8I, GL_R8I, GL_RED_INTEGER, GL_BYTE); + setTextureFormat(TextureFormat::R8U, GL_R8UI, GL_RED_INTEGER, GL_UNSIGNED_BYTE); setTextureFormat(TextureFormat::R16I, GL_R16I, GL_RED_INTEGER, GL_SHORT); setTextureFormat(TextureFormat::R16U, GL_R16UI, GL_RED_INTEGER, GL_UNSIGNED_SHORT); // setTextureFormat(TextureFormat::RG16, GL_RG16UI, GL_RG_INTEGER, GL_UNSIGNED_SHORT); @@ -3692,9 +3706,19 @@ namespace bgfx { namespace gl case GL_IMAGE_CUBE: case GL_INT_IMAGE_CUBE: case GL_UNSIGNED_INT_IMAGE_CUBE: - BX_TRACE("Sampler #%d at location %d.", m_numSamplers, loc); - m_sampler[m_numSamplers] = loc; - m_numSamplers++; + if (m_numSamplers < BX_COUNTOF(m_sampler) ) + { + BX_TRACE("Sampler #%d at location %d.", m_numSamplers, loc); + m_sampler[m_numSamplers] = loc; + m_numSamplers++; + } + else + { + BX_TRACE("Too many samplers (max: %d)! Sampler at location %d." + , BX_COUNTOF(m_sampler) + , loc + ); + } break; default: @@ -3949,7 +3973,7 @@ namespace bgfx { namespace gl } } - bool TextureGL::init(GLenum _target, uint32_t _width, uint32_t _height, uint32_t _depth, TextureFormat::Enum _format, uint8_t _numMips, uint32_t _flags) + bool TextureGL::init(GLenum _target, uint32_t _width, uint32_t _height, uint32_t _depth, uint8_t _numMips, uint32_t _flags) { m_target = _target; m_numMips = _numMips; @@ -3957,9 +3981,7 @@ namespace bgfx { namespace gl m_width = _width; m_height = _height; m_depth = _depth; - m_currentSamplerHash = UINT32_MAX; - m_requestedFormat = - m_textureFormat = uint8_t(_format); + m_currentSamplerHash = UINT32_MAX; const bool writeOnly = 0 != (m_flags&BGFX_TEXTURE_RT_WRITE_ONLY); const bool computeWrite = 0 != (m_flags&BGFX_TEXTURE_COMPUTE_WRITE ); @@ -3970,7 +3992,7 @@ namespace bgfx { namespace gl BX_CHECK(0 != m_id, "Failed to generate texture id."); GL_CHECK(glBindTexture(_target, m_id) ); - const TextureFormatInfo& tfi = s_textureFormat[_format]; + const TextureFormatInfo& tfi = s_textureFormat[m_textureFormat]; m_fmt = tfi.m_fmt; m_type = tfi.m_type; @@ -3979,11 +4001,9 @@ namespace bgfx { namespace gl && !s_textureFormat[m_requestedFormat].m_supported && !s_renderGL->m_textureSwizzleSupport ; - const bool compressed = isCompressed(TextureFormat::Enum(m_requestedFormat) ); - const bool convert = false - || (compressed && m_textureFormat != m_requestedFormat) + const bool convert = false + || m_textureFormat != m_requestedFormat || swizzle - || !s_textureFormat[m_requestedFormat].m_supported ; if (convert) @@ -4095,6 +4115,9 @@ namespace bgfx { namespace gl textureDepth = imageContainer.m_depth; } + m_requestedFormat = uint8_t(imageContainer.m_format); + m_textureFormat = uint8_t(getViableTextureFormat(imageContainer) ); + GLenum target = GL_TEXTURE_2D; if (imageContainer.m_cubeMap) { @@ -4109,7 +4132,6 @@ namespace bgfx { namespace gl , textureWidth , textureHeight , textureDepth - , imageContainer.m_format , numMips , _flags ) ) @@ -4590,7 +4612,7 @@ namespace bgfx { namespace gl for (uint32_t ii = 0; ii < count; ++ii) { - uint8_t nameSize; + uint8_t nameSize = 0; bx::read(&reader, nameSize); char name[256]; @@ -6638,4 +6660,3 @@ namespace bgfx { namespace gl } /* namespace gl */ } // namespace bgfx #endif // (BGFX_CONFIG_RENDERER_OPENGLES || BGFX_CONFIG_RENDERER_OPENGL) - diff --git a/3rdparty/bgfx/src/renderer_gl.h b/3rdparty/bgfx/src/renderer_gl.h index 91c49c22f02..884cc614ce5 100644 --- a/3rdparty/bgfx/src/renderer_gl.h +++ b/3rdparty/bgfx/src/renderer_gl.h @@ -222,6 +222,30 @@ typedef uint64_t GLuint64; # define GL_RG32F 0x8230 #endif // GL_RG32F +#ifndef GL_RGB8 +# define GL_RGB8 0x8051 +#endif // GL_RGB8 + +#ifndef GL_SRGB +# define GL_SRGB 0x8C40 +#endif // GL_SRGB + +#ifndef GL_SRGB8 +# define GL_SRGB8 0x8C41 +#endif // GL_SRGB8 + +#ifndef GL_RGB8I +# define GL_RGB8I 0x8D8F +#endif // GL_RGB8I + +#ifndef GL_RGB8UI +# define GL_RGB8UI 0x8D7D +#endif // GL_RGB8UI + +#ifndef GL_RGB8_SNORM +# define GL_RGB8_SNORM 0x8F96 +#endif // GL_RGB8_SNORM + #ifndef GL_RGBA8I # define GL_RGBA8I 0x8D8E #endif // GL_RGBA8I @@ -1120,7 +1144,7 @@ namespace bgfx { namespace gl { } - bool init(GLenum _target, uint32_t _width, uint32_t _height, uint32_t _depth, TextureFormat::Enum _format, uint8_t _numMips, uint32_t _flags); + bool init(GLenum _target, uint32_t _width, uint32_t _height, uint32_t _depth, uint8_t _numMips, uint32_t _flags); void create(const Memory* _mem, uint32_t _flags, uint8_t _skip); void destroy(); void overrideInternal(uintptr_t _ptr); diff --git a/3rdparty/bgfx/src/renderer_mtl.mm b/3rdparty/bgfx/src/renderer_mtl.mm index 08faee495f7..ffb2c38a793 100644 --- a/3rdparty/bgfx/src/renderer_mtl.mm +++ b/3rdparty/bgfx/src/renderer_mtl.mm @@ -1855,20 +1855,10 @@ namespace bgfx { namespace mtl const uint32_t textureHeight = bx::uint32_max(blockInfo.blockHeight, imageContainer.m_height>>startLod); m_flags = _flags; - m_requestedFormat = (uint8_t)imageContainer.m_format; - m_textureFormat = MTLPixelFormatInvalid == s_textureFormat[m_requestedFormat].m_fmt - ? uint8_t(TextureFormat::BGRA8) - : m_requestedFormat - ; - - const bool convert = m_requestedFormat != m_textureFormat; - - uint8_t bpp = getBitsPerPixel(TextureFormat::Enum(m_textureFormat) ); - if (convert) - { - m_textureFormat = (uint8_t)TextureFormat::RGBA8; - bpp = 32; - } + m_requestedFormat = uint8_t(imageContainer.m_format); + m_textureFormat = uint8_t(getViableTextureFormat(imageContainer) ); + const bool convert = m_textureFormat != m_requestedFormat; + const uint8_t bpp = getBitsPerPixel(TextureFormat::Enum(m_textureFormat) ); TextureDescriptor desc = s_renderMtl->m_textureDescriptor; diff --git a/3rdparty/bgfx/src/renderer_vk.cpp b/3rdparty/bgfx/src/renderer_vk.cpp index 31455c1992f..e885b84e58f 100644 --- a/3rdparty/bgfx/src/renderer_vk.cpp +++ b/3rdparty/bgfx/src/renderer_vk.cpp @@ -6,7 +6,7 @@ #include "bgfx_p.h" #if BGFX_CONFIG_RENDERER_VULKAN -# include "../../bgfx-ext/src/renderer_vk.cpp" +# include "../../bgfx-ext/src/renderer_vk1.cpp" #else namespace bgfx { namespace vk diff --git a/3rdparty/bgfx/src/shader_dx9bc.cpp b/3rdparty/bgfx/src/shader_dx9bc.cpp index 071a9e2705e..bb2b6a0e4db 100644 --- a/3rdparty/bgfx/src/shader_dx9bc.cpp +++ b/3rdparty/bgfx/src/shader_dx9bc.cpp @@ -274,12 +274,12 @@ namespace bgfx }; BX_STATIC_ASSERT(BX_COUNTOF(s_dx9bcDeclUsage) == Dx9bcDeclUsage::Count); - int32_t read(bx::ReaderI* _reader, Dx9bcSubOperand& _subOperand) + int32_t read(bx::ReaderI* _reader, Dx9bcSubOperand& _subOperand, bx::Error* _err) { int32_t size = 0; uint32_t token; - size += bx::read(_reader, token); + size += bx::read(_reader, token, _err); _subOperand.type = Dx9bcOperandType::Enum( ( (token & UINT32_C(0x70000000) ) >> 28) | ( (token & UINT32_C(0x00001800) ) >> 8) ); @@ -289,7 +289,7 @@ namespace bgfx return size; } - int32_t write(bx::WriterI* _writer, const Dx9bcSubOperand& _subOperand) + int32_t write(bx::WriterI* _writer, const Dx9bcSubOperand& _subOperand, bx::Error* _err) { int32_t size = 0; @@ -298,17 +298,17 @@ namespace bgfx token |= (_subOperand.type << 8) & UINT32_C(0x00001800); token |= _subOperand.regIndex & UINT32_C(0x000007ff); token |= (_subOperand.swizzleBits << 16) & UINT32_C(0x00ff0000); - size += bx::write(_writer, token); + size += bx::write(_writer, token, _err); return size; } - int32_t read(bx::ReaderI* _reader, Dx9bcOperand& _operand) + int32_t read(bx::ReaderI* _reader, Dx9bcOperand& _operand, bx::Error* _err) { int32_t size = 0; uint32_t token; - size += bx::read(_reader, token); + size += bx::read(_reader, token, _err); _operand.type = Dx9bcOperandType::Enum( ( (token & UINT32_C(0x70000000) ) >> 28) | ( (token & UINT32_C(0x00001800) ) >> 8) ); @@ -339,13 +339,13 @@ namespace bgfx if (Dx9bcOperandAddrMode::Relative == _operand.addrMode) { - size += read(_reader, _operand.subOperand); + size += read(_reader, _operand.subOperand, _err); } return size; } - int32_t write(bx::WriterI* _writer, const Dx9bcOperand& _operand) + int32_t write(bx::WriterI* _writer, const Dx9bcOperand& _operand, bx::Error* _err) { int32_t size = 0; @@ -354,22 +354,22 @@ namespace bgfx token |= (_operand.type << 8) & UINT32_C(0x00001800); token |= _operand.regIndex & UINT32_C(0x000007ff); token |= (_operand.addrMode << 13) & UINT32_C(0x00002000); - size += bx::write(_writer, token); + size += bx::write(_writer, token, _err); if (Dx9bcOperandAddrMode::Relative == _operand.addrMode) { - size += write(_writer, _operand.subOperand); + size += write(_writer, _operand.subOperand, _err); } return size; } - int32_t read(bx::ReaderI* _reader, Dx9bcInstruction& _instruction) + int32_t read(bx::ReaderI* _reader, Dx9bcInstruction& _instruction, bx::Error* _err) { int32_t size = 0; uint32_t token; - size += bx::read(_reader, token); + size += bx::read(_reader, token, _err); _instruction.opcode = Dx9bcOpcode::Enum( (token & UINT32_C(0x0000ffff) ) ); @@ -395,7 +395,7 @@ namespace bgfx for (int32_t ii = 0, num = _instruction.length-1; ii < num; ++ii) { uint32_t tmp; - size += bx::read(_reader, tmp); + size += bx::read(_reader, tmp, _err); } } @@ -436,24 +436,24 @@ namespace bgfx if (valuesBeforeOpcode && 0 < info.numValues) { - size += read(_reader, _instruction.value, info.numValues*sizeof(uint32_t) ); + size += read(_reader, _instruction.value, info.numValues*sizeof(uint32_t), _err); } _instruction.operand[0].destination = true; switch (_instruction.numOperands) { - case 6: size += read(_reader, _instruction.operand[currOp++]); - case 5: size += read(_reader, _instruction.operand[currOp++]); - case 4: size += read(_reader, _instruction.operand[currOp++]); - case 3: size += read(_reader, _instruction.operand[currOp++]); - case 2: size += read(_reader, _instruction.operand[currOp++]); - case 1: size += read(_reader, _instruction.operand[currOp++]); + case 6: size += read(_reader, _instruction.operand[currOp++], _err); + case 5: size += read(_reader, _instruction.operand[currOp++], _err); + case 4: size += read(_reader, _instruction.operand[currOp++], _err); + case 3: size += read(_reader, _instruction.operand[currOp++], _err); + case 2: size += read(_reader, _instruction.operand[currOp++], _err); + case 1: size += read(_reader, _instruction.operand[currOp++], _err); case 0: if (!valuesBeforeOpcode && 0 < info.numValues) { - size += read(_reader, _instruction.value, info.numValues*sizeof(uint32_t) ); + size += read(_reader, _instruction.value, info.numValues*sizeof(uint32_t), _err); } break; @@ -469,7 +469,7 @@ namespace bgfx return size; } - int32_t write(bx::WriterI* _writer, const Dx9bcInstruction& _instruction) + int32_t write(bx::WriterI* _writer, const Dx9bcInstruction& _instruction, bx::Error* _err) { int32_t size = 0; @@ -477,17 +477,17 @@ namespace bgfx token |= _instruction.opcode & UINT32_C(0x0000ffff); token |= (_instruction.specific << 16) & UINT32_C(0x00ff0000); token |= ( (_instruction.length - 1) << 24) & UINT32_C(0x0f000000); - size += bx::write(_writer, token); + size += bx::write(_writer, token, _err); uint32_t currOp = 0; switch (_instruction.numOperands) { - case 6: size += write(_writer, _instruction.operand[currOp++]); - case 5: size += write(_writer, _instruction.operand[currOp++]); - case 4: size += write(_writer, _instruction.operand[currOp++]); - case 3: size += write(_writer, _instruction.operand[currOp++]); - case 2: size += write(_writer, _instruction.operand[currOp++]); - case 1: size += write(_writer, _instruction.operand[currOp++]); + case 6: size += write(_writer, _instruction.operand[currOp++], _err); + case 5: size += write(_writer, _instruction.operand[currOp++], _err); + case 4: size += write(_writer, _instruction.operand[currOp++], _err); + case 3: size += write(_writer, _instruction.operand[currOp++], _err); + case 2: size += write(_writer, _instruction.operand[currOp++], _err); + case 1: size += write(_writer, _instruction.operand[currOp++], _err); case 0: break; } @@ -626,7 +626,7 @@ namespace bgfx return size; } - int32_t read(bx::ReaderSeekerI* _reader, Dx9bcShader& _shader) + int32_t read(bx::ReaderSeekerI* _reader, Dx9bcShader& _shader, bx::Error* _err) { int32_t size = 0; int64_t offset = bx::seek(_reader); @@ -634,7 +634,7 @@ namespace bgfx for (;;) { Dx9bcInstruction instruction; - int32_t length = read(_reader, instruction); + int32_t length = read(_reader, instruction, _err); size += length; if (Dx9bcOpcode::Count > instruction.opcode) @@ -662,22 +662,22 @@ namespace bgfx bx::seek(_reader, offset, bx::Whence::Begin); _shader.byteCode.resize(size); - bx::read(_reader, _shader.byteCode.data(), size); + bx::read(_reader, _shader.byteCode.data(), size, _err); return size; } - int32_t write(bx::WriterI* _writer, const Dx9bcShader& _shader) + int32_t write(bx::WriterI* _writer, const Dx9bcShader& _shader, bx::Error* _err) { - BX_UNUSED(_writer, _shader); + BX_UNUSED(_writer, _shader, _err); return 0; } - int32_t read(bx::ReaderSeekerI* _reader, Dx9bc& _bc) + int32_t read(bx::ReaderSeekerI* _reader, Dx9bc& _bc, bx::Error* _err) { int32_t size = 0; - size += bx::read(_reader, _bc.version); + size += bx::read(_reader, _bc.version, _err); bool pixelShader = (0xffff0000 == (_bc.version & 0xffff0000) ); uint32_t versionMajor = (_bc.version>>8)&0xff; @@ -689,37 +689,45 @@ namespace bgfx , versionMinor ); - size += read(_reader, _bc.shader); + size += read(_reader, _bc.shader, _err); return size; } - int32_t write(bx::WriterSeekerI* _writer, const Dx9bc& _dxbc) + int32_t write(bx::WriterSeekerI* _writer, const Dx9bc& _dxbc, bx::Error* _err) { - BX_UNUSED(_writer, _dxbc); + BX_UNUSED(_writer, _dxbc, _err); return 0; } - void parse(const Dx9bcShader& _src, Dx9bcParseFn _fn, void* _userData) + void parse(const Dx9bcShader& _src, Dx9bcParseFn _fn, void* _userData, bx::Error* _err) { + BX_ERROR_SCOPE(_err); + bx::MemoryReader reader(_src.byteCode.data(), uint32_t(_src.byteCode.size() ) ); -//BX_TRACE("parse %d", _src.byteCode.size()); + bx::Error err; for (uint32_t token = 0, numTokens = uint32_t(_src.byteCode.size() / sizeof(uint32_t) ); token < numTokens;) { Dx9bcInstruction instruction; - uint32_t size = read(&reader, instruction); + uint32_t size = read(&reader, instruction, _err); BX_CHECK(size/4 == instruction.length, "read %d, expected %d", size/4, instruction.length); BX_UNUSED(size); - _fn(token * sizeof(uint32_t), instruction, _userData); + bool cont = _fn(token * sizeof(uint32_t), instruction, _userData); + if (!cont) + { + return; + } token += instruction.length; } } - void filter(Dx9bcShader& _dst, const Dx9bcShader& _src, Dx9bcFilterFn _fn, void* _userData) + void filter(Dx9bcShader& _dst, const Dx9bcShader& _src, Dx9bcFilterFn _fn, void* _userData, bx::Error* _err) { + BX_ERROR_SCOPE(_err); + bx::MemoryReader reader(_src.byteCode.data(), uint32_t(_src.byteCode.size() ) ); bx::MemoryBlock mb(g_allocator); @@ -728,7 +736,7 @@ namespace bgfx for (uint32_t token = 0, numTokens = uint32_t(_src.byteCode.size() / sizeof(uint32_t) ); token < numTokens;) { Dx9bcInstruction instruction; - uint32_t size = read(&reader, instruction); + uint32_t size = read(&reader, instruction, _err); BX_CHECK(size/4 == instruction.length, "read %d, expected %d", size/4, instruction.length); BX_UNUSED(size); _fn(instruction, _userData); diff --git a/3rdparty/bgfx/src/shader_dx9bc.h b/3rdparty/bgfx/src/shader_dx9bc.h index d7b6b381dc3..0680d641a12 100644 --- a/3rdparty/bgfx/src/shader_dx9bc.h +++ b/3rdparty/bgfx/src/shader_dx9bc.h @@ -226,8 +226,8 @@ namespace bgfx int32_t value[4]; }; - int32_t read(bx::ReaderI* _reader, Dx9bcInstruction& _instruction); - int32_t write(bx::WriterI* _writer, const Dx9bcInstruction& _instruction); + int32_t read(bx::ReaderI* _reader, Dx9bcInstruction& _instruction, bx::Error* _err); + int32_t write(bx::WriterI* _writer, const Dx9bcInstruction& _instruction, bx::Error* _err); int32_t toString(char* _out, int32_t _size, const Dx9bcInstruction& _instruction); struct Dx9bcShader @@ -235,8 +235,8 @@ namespace bgfx stl::vector<uint8_t> byteCode; }; - int32_t read(bx::ReaderSeekerI* _reader, Dx9bcShader& _shader); - int32_t write(bx::WriterI* _writer, const Dx9bcShader& _shader); + int32_t read(bx::ReaderSeekerI* _reader, Dx9bcShader& _shader, bx::Error* _err); + int32_t write(bx::WriterI* _writer, const Dx9bcShader& _shader, bx::Error* _err); struct Dx9bc { @@ -244,14 +244,14 @@ namespace bgfx Dx9bcShader shader; }; - int32_t read(bx::ReaderSeekerI* _reader, Dx9bc& _dx9bc); - int32_t write(bx::WriterSeekerI* _writer, const Dx9bc& _dx9bc); + int32_t read(bx::ReaderSeekerI* _reader, Dx9bc& _dx9bc, bx::Error* _err); + int32_t write(bx::WriterSeekerI* _writer, const Dx9bc& _dx9bc, bx::Error* _err); - typedef void (*Dx9bcParseFn)(uint32_t _offset, const Dx9bcInstruction& _instruction, void* _userData); - void parse(const Dx9bcShader& _src, Dx9bcParseFn _fn, void* _userData); + typedef bool (*Dx9bcParseFn)(uint32_t _offset, const Dx9bcInstruction& _instruction, void* _userData); + void parse(const Dx9bcShader& _src, Dx9bcParseFn _fn, void* _userData, bx::Error* _err = NULL); typedef void (*Dx9bcFilterFn)(Dx9bcInstruction& _instruction, void* _userData); - void filter(Dx9bcShader& _dst, const Dx9bcShader& _src, Dx9bcFilterFn _fn, void* _userData); + void filter(Dx9bcShader& _dst, const Dx9bcShader& _src, Dx9bcFilterFn _fn, void* _userData, bx::Error* _err = NULL); } // namespace bgfx diff --git a/3rdparty/bgfx/src/shader_dxbc.cpp b/3rdparty/bgfx/src/shader_dxbc.cpp index 36d81842c8d..9f8b351e76a 100644 --- a/3rdparty/bgfx/src/shader_dxbc.cpp +++ b/3rdparty/bgfx/src/shader_dxbc.cpp @@ -552,7 +552,7 @@ namespace bgfx #define DXBC_MAX_NAME_STRING 512 - int32_t readString(bx::ReaderSeekerI* _reader, int64_t _offset, char* _out, uint32_t _max = DXBC_MAX_NAME_STRING) + int32_t readString(bx::ReaderSeekerI* _reader, int64_t _offset, char* _out, uint32_t _max, bx::Error* _err) { int64_t oldOffset = bx::seek(_reader); bx::seek(_reader, _offset, bx::Whence::Begin); @@ -562,7 +562,7 @@ namespace bgfx for (uint32_t ii = 0; ii < _max-1; ++ii) { char ch; - size += bx::read(_reader, ch); + size += bx::read(_reader, ch, _err); *_out++ = ch; if ('\0' == ch) @@ -755,7 +755,7 @@ namespace bgfx memcpy(_digest, hash, 16); } - int32_t read(bx::ReaderI* _reader, DxbcSubOperand& _subOperand) + int32_t read(bx::ReaderI* _reader, DxbcSubOperand& _subOperand, bx::Error* _err) { uint32_t token; int32_t size = 0; @@ -773,7 +773,7 @@ namespace bgfx // |+------------------------------- addressing mode 2 // +-------------------------------- extended - size += bx::read(_reader, token); + size += bx::read(_reader, token, _err); _subOperand.type = DxbcOperandType::Enum( (token & UINT32_C(0x000ff000) ) >> 12); _subOperand.numAddrModes = uint8_t( (token & UINT32_C(0x00300000) ) >> 20); _subOperand.addrMode = uint8_t( (token & UINT32_C(0x01c00000) ) >> 22); @@ -784,7 +784,7 @@ namespace bgfx switch (_subOperand.addrMode) { case DxbcOperandAddrMode::Imm32: - size += bx::read(_reader, _subOperand.regIndex); + size += bx::read(_reader, _subOperand.regIndex, _err); break; case DxbcOperandAddrMode::Reg: @@ -796,7 +796,7 @@ namespace bgfx case DxbcOperandAddrMode::RegImm32: { - size += bx::read(_reader, _subOperand.regIndex); + size += bx::read(_reader, _subOperand.regIndex, _err); DxbcSubOperand subOperand; size += read(_reader, subOperand); @@ -805,8 +805,8 @@ namespace bgfx case DxbcOperandAddrMode::RegImm64: { - size += bx::read(_reader, _subOperand.regIndex); - size += bx::read(_reader, _subOperand.regIndex); + size += bx::read(_reader, _subOperand.regIndex, _err); + size += bx::read(_reader, _subOperand.regIndex, _err); DxbcSubOperand subOperand; size += read(_reader, subOperand); @@ -821,7 +821,7 @@ namespace bgfx return size; } - int32_t write(bx::WriterI* _writer, const DxbcSubOperand& _subOperand) + int32_t write(bx::WriterI* _writer, const DxbcSubOperand& _subOperand, bx::Error* _err) { int32_t size = 0; @@ -832,12 +832,12 @@ namespace bgfx token |= (_subOperand.mode << 2) & UINT32_C(0x0000000c); token |= (_subOperand.modeBits << 4) & UINT32_C(0x00000ff0); token |= _subOperand.num & UINT32_C(0x00000003); - size += bx::write(_writer, token); + size += bx::write(_writer, token, _err); switch (_subOperand.addrMode) { case DxbcOperandAddrMode::Imm32: - size += bx::write(_writer, _subOperand.regIndex); + size += bx::write(_writer, _subOperand.regIndex, _err); break; case DxbcOperandAddrMode::Reg: @@ -849,7 +849,7 @@ namespace bgfx case DxbcOperandAddrMode::RegImm32: { - size += bx::write(_writer, _subOperand.regIndex); + size += bx::write(_writer, _subOperand.regIndex, _err); DxbcSubOperand subOperand; size += write(_writer, subOperand); @@ -858,8 +858,8 @@ namespace bgfx case DxbcOperandAddrMode::RegImm64: { - size += bx::write(_writer, _subOperand.regIndex); - size += bx::write(_writer, _subOperand.regIndex); + size += bx::write(_writer, _subOperand.regIndex, _err); + size += bx::write(_writer, _subOperand.regIndex, _err); DxbcSubOperand subOperand; size += write(_writer, subOperand); @@ -874,12 +874,12 @@ namespace bgfx return size; } - int32_t read(bx::ReaderI* _reader, DxbcOperand& _operand) + int32_t read(bx::ReaderI* _reader, DxbcOperand& _operand, bx::Error* _err) { int32_t size = 0; uint32_t token; - size += bx::read(_reader, token); + size += bx::read(_reader, token, _err); // 0 1 2 3 // 76543210765432107654321076543210 @@ -906,7 +906,7 @@ namespace bgfx if (_operand.extended) { - size += bx::read(_reader, _operand.extBits); + size += bx::read(_reader, _operand.extBits, _err); } switch (_operand.type) @@ -915,7 +915,7 @@ namespace bgfx _operand.num = 2 == _operand.num ? 4 : _operand.num; for (uint32_t ii = 0; ii < _operand.num; ++ii) { - size += bx::read(_reader, _operand.un.imm32[ii]); + size += bx::read(_reader, _operand.un.imm32[ii], _err); } break; @@ -923,7 +923,7 @@ namespace bgfx _operand.num = 2 == _operand.num ? 4 : _operand.num; for (uint32_t ii = 0; ii < _operand.num; ++ii) { - size += bx::read(_reader, _operand.un.imm64[ii]); + size += bx::read(_reader, _operand.un.imm64[ii], _err); } break; @@ -936,16 +936,16 @@ namespace bgfx switch (_operand.addrMode[ii]) { case DxbcOperandAddrMode::Imm32: - size += bx::read(_reader, _operand.regIndex[ii]); + size += bx::read(_reader, _operand.regIndex[ii], _err); break; case DxbcOperandAddrMode::Reg: - size += read(_reader, _operand.subOperand[ii]); + size += read(_reader, _operand.subOperand[ii], _err); break; case DxbcOperandAddrMode::RegImm32: - size += bx::read(_reader, _operand.regIndex[ii]); - size += read(_reader, _operand.subOperand[ii]); + size += bx::read(_reader, _operand.regIndex[ii], _err); + size += read(_reader, _operand.subOperand[ii], _err); break; default: @@ -957,7 +957,7 @@ namespace bgfx return size; } - int32_t write(bx::WriterI* _writer, const DxbcOperand& _operand) + int32_t write(bx::WriterI* _writer, const DxbcOperand& _operand, bx::Error* _err) { int32_t size = 0; @@ -973,7 +973,7 @@ namespace bgfx token |= (4 == _operand.num ? 2 : _operand.num) & UINT32_C(0x00000003); token |= ( (_operand.modeBits & "\x0f\xff\x03\x00"[_operand.mode]) << 4) & UINT32_C(0x00000ff0); - size += bx::write(_writer, token); + size += bx::write(_writer, token, _err); if (_operand.extended) { @@ -985,14 +985,14 @@ namespace bgfx case DxbcOperandType::Imm32: for (uint32_t ii = 0; ii < _operand.num; ++ii) { - size += bx::write(_writer, _operand.un.imm32[ii]); + size += bx::write(_writer, _operand.un.imm32[ii], _err); } break; case DxbcOperandType::Imm64: for (uint32_t ii = 0; ii < _operand.num; ++ii) { - size += bx::write(_writer, _operand.un.imm64[ii]); + size += bx::write(_writer, _operand.un.imm64[ii], _err); } break; @@ -1005,16 +1005,16 @@ namespace bgfx switch (_operand.addrMode[ii]) { case DxbcOperandAddrMode::Imm32: - size += bx::write(_writer, _operand.regIndex[ii]); + size += bx::write(_writer, _operand.regIndex[ii], _err); break; case DxbcOperandAddrMode::Reg: - size += write(_writer, _operand.subOperand[ii]); + size += write(_writer, _operand.subOperand[ii], _err); break; case DxbcOperandAddrMode::RegImm32: - size += bx::write(_writer, _operand.regIndex[ii]); - size += write(_writer, _operand.subOperand[ii]); + size += bx::write(_writer, _operand.regIndex[ii], _err); + size += write(_writer, _operand.subOperand[ii], _err); break; default: @@ -1026,12 +1026,12 @@ namespace bgfx return size; } - int32_t read(bx::ReaderI* _reader, DxbcInstruction& _instruction) + int32_t read(bx::ReaderI* _reader, DxbcInstruction& _instruction, bx::Error* _err) { uint32_t size = 0; uint32_t token; - size += bx::read(_reader, token); + size += bx::read(_reader, token, _err); // 0 1 2 3 // 76543210765432107654321076543210 @@ -1077,7 +1077,7 @@ namespace bgfx for (uint32_t ii = 0, num = (_instruction.length-2)/4; ii < num; ++ii) { char temp[16]; - size += bx::read(_reader, temp, 16); + size += bx::read(_reader, temp, 16, _err); } } @@ -1190,7 +1190,7 @@ namespace bgfx uint32_t extBits; size += bx::read(_reader, extBits); extended = 0 != (extBits & UINT32_C(0x80000000) ); - _instruction.extended[ii] = DxbcInstruction::ExtendedType::Enum(extBits & UINT32_C(0x0000001f) ); + _instruction.extended[ii ] = DxbcInstruction::ExtendedType::Enum(extBits & UINT32_C(0x0000001f) ); _instruction.extended[ii+1] = DxbcInstruction::ExtendedType::Count; switch (_instruction.extended[ii]) @@ -1244,7 +1244,7 @@ namespace bgfx case DxbcOpcode::DCL_FUNCTION_TABLE: { uint32_t tableId; - size += read(_reader, tableId); + size += read(_reader, tableId, _err); uint32_t num; size += read(_reader, num); @@ -1252,7 +1252,7 @@ namespace bgfx for (uint32_t ii = 0; ii < num; ++ii) { uint32_t bodyId; - size += read(_reader, bodyId); + size += read(_reader, bodyId, _err); } } break; @@ -1260,10 +1260,10 @@ namespace bgfx case DxbcOpcode::DCL_INTERFACE: { uint32_t interfaceId; - size += read(_reader, interfaceId); + size += read(_reader, interfaceId, _err); uint32_t num; - size += read(_reader, num); + size += read(_reader, num, _err); BX_CHECK(false, "not implemented."); } @@ -1279,16 +1279,16 @@ namespace bgfx _instruction.numOperands = info.numOperands; switch (info.numOperands) { - case 6: size += read(_reader, _instruction.operand[currOp++]); - case 5: size += read(_reader, _instruction.operand[currOp++]); - case 4: size += read(_reader, _instruction.operand[currOp++]); - case 3: size += read(_reader, _instruction.operand[currOp++]); - case 2: size += read(_reader, _instruction.operand[currOp++]); - case 1: size += read(_reader, _instruction.operand[currOp++]); + case 6: size += read(_reader, _instruction.operand[currOp++], _err); + case 5: size += read(_reader, _instruction.operand[currOp++], _err); + case 4: size += read(_reader, _instruction.operand[currOp++], _err); + case 3: size += read(_reader, _instruction.operand[currOp++], _err); + case 2: size += read(_reader, _instruction.operand[currOp++], _err); + case 1: size += read(_reader, _instruction.operand[currOp++], _err); case 0: if (0 < info.numValues) { - size += read(_reader, _instruction.value, info.numValues*sizeof(uint32_t) ); + size += read(_reader, _instruction.value, info.numValues*sizeof(uint32_t), _err); } break; @@ -1304,7 +1304,7 @@ namespace bgfx return size; } - int32_t write(bx::WriterI* _writer, const DxbcInstruction& _instruction) + int32_t write(bx::WriterI* _writer, const DxbcInstruction& _instruction, bx::Error* _err) { uint32_t token = 0; token |= (_instruction.opcode ) & UINT32_C(0x000007ff); @@ -1366,7 +1366,7 @@ namespace bgfx uint32_t size =0; size += bx::write(_writer, token); -; + for (uint32_t ii = 0; _instruction.extended[ii] != DxbcInstruction::ExtendedType::Count; ++ii) { // 0 1 2 3 @@ -1427,18 +1427,18 @@ namespace bgfx break; } - size += bx::write(_writer, token); + size += bx::write(_writer, token, _err); } for (uint32_t ii = 0; ii < _instruction.numOperands; ++ii) { - size += write(_writer, _instruction.operand[ii]); + size += write(_writer, _instruction.operand[ii], _err); } const DxbcOpcodeInfo& info = s_dxbcOpcodeInfo[_instruction.opcode]; if (0 < info.numValues) { - size += bx::write(_writer, _instruction.value, info.numValues*sizeof(uint32_t) ); + size += bx::write(_writer, _instruction.value, info.numValues*sizeof(uint32_t), _err); } return size; @@ -1609,15 +1609,15 @@ namespace bgfx return size; } - int32_t read(bx::ReaderSeekerI* _reader, DxbcSignature& _signature) + int32_t read(bx::ReaderSeekerI* _reader, DxbcSignature& _signature, bx::Error* _err) { int32_t size = 0; int64_t offset = bx::seek(_reader); uint32_t num; - size += bx::read(_reader, num); - size += bx::read(_reader, _signature.key); + size += bx::read(_reader, num, _err); + size += bx::read(_reader, _signature.key, _err); for (uint32_t ii = 0; ii < num; ++ii) { @@ -1627,20 +1627,20 @@ namespace bgfx size += bx::read(_reader, nameOffset); char name[DXBC_MAX_NAME_STRING]; - readString(_reader, offset + nameOffset, name); + readString(_reader, offset + nameOffset, name, DXBC_MAX_NAME_STRING, _err); element.name = name; - size += bx::read(_reader, element.semanticIndex); - size += bx::read(_reader, element.valueType); - size += bx::read(_reader, element.componentType); - size += bx::read(_reader, element.registerIndex); - size += bx::read(_reader, element.mask); - size += bx::read(_reader, element.readWriteMask); - size += bx::read(_reader, element.stream); + size += bx::read(_reader, element.semanticIndex, _err); + size += bx::read(_reader, element.valueType, _err); + size += bx::read(_reader, element.componentType, _err); + size += bx::read(_reader, element.registerIndex, _err); + size += bx::read(_reader, element.mask, _err); + size += bx::read(_reader, element.readWriteMask, _err); + size += bx::read(_reader, element.stream, _err); // padding uint8_t padding; - size += bx::read(_reader, padding); + size += bx::read(_reader, padding, _err); _signature.elements.push_back(element); } @@ -1648,13 +1648,13 @@ namespace bgfx return size; } - int32_t write(bx::WriterI* _writer, const DxbcSignature& _signature) + int32_t write(bx::WriterI* _writer, const DxbcSignature& _signature, bx::Error* _err) { int32_t size = 0; const uint32_t num = uint32_t(_signature.elements.size() ); - size += bx::write(_writer, num); - size += bx::write(_writer, _signature.key); + size += bx::write(_writer, num, _err); + size += bx::write(_writer, _signature.key, _err); typedef stl::unordered_map<stl::string, uint32_t> NameOffsetMap; NameOffsetMap nom; @@ -1669,7 +1669,7 @@ namespace bgfx if (it == nom.end() ) { nom.insert(stl::make_pair(element.name, nameOffset) ); - size += bx::write(_writer, nameOffset); + size += bx::write(_writer, nameOffset, _err); nameOffset += uint32_t(element.name.size() + 1); } else @@ -1677,15 +1677,14 @@ namespace bgfx size += bx::write(_writer, it->second); } - size += bx::write(_writer, element.semanticIndex); - size += bx::write(_writer, element.valueType); - size += bx::write(_writer, element.componentType); - size += bx::write(_writer, element.registerIndex); - size += bx::write(_writer, element.mask); - size += bx::write(_writer, element.readWriteMask); - size += bx::write(_writer, element.stream); - size += bx::write(_writer, pad); - + size += bx::write(_writer, element.semanticIndex, _err); + size += bx::write(_writer, element.valueType, _err); + size += bx::write(_writer, element.componentType, _err); + size += bx::write(_writer, element.registerIndex, _err); + size += bx::write(_writer, element.mask, _err); + size += bx::write(_writer, element.readWriteMask, _err); + size += bx::write(_writer, element.stream, _err); + size += bx::write(_writer, pad, _err); } uint32_t len = 0; @@ -1696,42 +1695,42 @@ namespace bgfx if (it != nom.end() ) { nom.erase(it); - size += bx::write(_writer, element.name.c_str(), uint32_t(element.name.size() + 1) ); + size += bx::write(_writer, element.name.c_str(), uint32_t(element.name.size() + 1), _err); len += uint32_t(element.name.size() + 1); } } // align 4 bytes - size += bx::writeRep(_writer, 0xab, (len+3)/4*4 - len); + size += bx::writeRep(_writer, 0xab, (len+3)/4*4 - len, _err); return size; } - int32_t read(bx::ReaderSeekerI* _reader, DxbcShader& _shader) + int32_t read(bx::ReaderSeekerI* _reader, DxbcShader& _shader, bx::Error* _err) { int32_t size = 0; - size += bx::read(_reader, _shader.version); + size += bx::read(_reader, _shader.version, _err); uint32_t bcLength; - size += bx::read(_reader, bcLength); + size += bx::read(_reader, bcLength, _err); uint32_t len = (bcLength-2)*sizeof(uint32_t); _shader.byteCode.resize(len); - size += bx::read(_reader, _shader.byteCode.data(), len); + size += bx::read(_reader, _shader.byteCode.data(), len, _err); return size; } - int32_t write(bx::WriterI* _writer, const DxbcShader& _shader) + int32_t write(bx::WriterI* _writer, const DxbcShader& _shader, bx::Error* _err) { const uint32_t len = uint32_t(_shader.byteCode.size() ); const uint32_t bcLength = len / sizeof(uint32_t) + 2; int32_t size = 0; - size += bx::write(_writer, _shader.version); - size += bx::write(_writer, bcLength); - size += bx::write(_writer, _shader.byteCode.data(), len); + size += bx::write(_writer, _shader.version, _err); + size += bx::write(_writer, bcLength, _err); + size += bx::write(_writer, _shader.byteCode.data(), len, _err); return size; } @@ -1743,10 +1742,10 @@ namespace bgfx #define DXBC_CHUNK_INPUT_SIGNATURE BX_MAKEFOURCC('I', 'S', 'G', 'N') #define DXBC_CHUNK_OUTPUT_SIGNATURE BX_MAKEFOURCC('O', 'S', 'G', 'N') - int32_t read(bx::ReaderSeekerI* _reader, DxbcContext& _dxbc) + int32_t read(bx::ReaderSeekerI* _reader, DxbcContext& _dxbc, bx::Error* _err) { int32_t size = 0; - size += bx::read(_reader, _dxbc.header); + size += bx::read(_reader, _dxbc.header, _err); _dxbc.shader.shex = false; for (uint32_t ii = 0; ii < _dxbc.header.numChunks; ++ii) @@ -1754,15 +1753,15 @@ namespace bgfx bx::seek(_reader, sizeof(DxbcContext::Header) + ii*sizeof(uint32_t), bx::Whence::Begin); uint32_t chunkOffset; - size += bx::read(_reader, chunkOffset); + size += bx::read(_reader, chunkOffset, _err); bx::seek(_reader, chunkOffset, bx::Whence::Begin); uint32_t fourcc; - size += bx::read(_reader, fourcc); + size += bx::read(_reader, fourcc, _err); uint32_t chunkSize; - size += bx::read(_reader, chunkSize); + size += bx::read(_reader, chunkSize, _err); switch (fourcc) { @@ -1771,18 +1770,18 @@ namespace bgfx // fallthrough case DXBC_CHUNK_SHADER: - size += read(_reader, _dxbc.shader); + size += read(_reader, _dxbc.shader, _err); break; case BX_MAKEFOURCC('I', 'S', 'G', '1'): case DXBC_CHUNK_INPUT_SIGNATURE: - size += read(_reader, _dxbc.inputSignature); + size += read(_reader, _dxbc.inputSignature, _err); break; case BX_MAKEFOURCC('O', 'S', 'G', '1'): case BX_MAKEFOURCC('O', 'S', 'G', '5'): case DXBC_CHUNK_OUTPUT_SIGNATURE: - size += read(_reader, _dxbc.outputSignature); + size += read(_reader, _dxbc.outputSignature, _err); break; case BX_MAKEFOURCC('A', 'o', 'n', '9'): // Contains DX9BC for feature level 9.x (*s_4_0_level_9_*) shaders. @@ -1816,43 +1815,43 @@ namespace bgfx return size; } - int32_t write(bx::WriterSeekerI* _writer, const DxbcContext& _dxbc) + int32_t write(bx::WriterSeekerI* _writer, const DxbcContext& _dxbc, bx::Error* _err) { int32_t size = 0; int64_t dxbcOffset = bx::seek(_writer); size += bx::write(_writer, DXBC_CHUNK_HEADER); - size += bx::writeRep(_writer, 0, 16); + size += bx::writeRep(_writer, 0, 16, _err); - size += bx::write(_writer, UINT32_C(1) ); + size += bx::write(_writer, UINT32_C(1), _err); int64_t sizeOffset = bx::seek(_writer); - size += bx::writeRep(_writer, 0, 4); + size += bx::writeRep(_writer, 0, 4, _err); uint32_t numChunks = 3; - size += bx::write(_writer, numChunks); + size += bx::write(_writer, numChunks, _err); int64_t chunksOffsets = bx::seek(_writer); - size += bx::writeRep(_writer, 0, numChunks*sizeof(uint32_t) ); + size += bx::writeRep(_writer, 0, numChunks*sizeof(uint32_t), _err); uint32_t chunkOffset[3]; uint32_t chunkSize[3]; chunkOffset[0] = uint32_t(bx::seek(_writer) - dxbcOffset); - size += write(_writer, DXBC_CHUNK_INPUT_SIGNATURE); - size += write(_writer, UINT32_C(0) ); - chunkSize[0] = write(_writer, _dxbc.inputSignature); + size += write(_writer, DXBC_CHUNK_INPUT_SIGNATURE, _err); + size += write(_writer, UINT32_C(0), _err); + chunkSize[0] = write(_writer, _dxbc.inputSignature, _err); chunkOffset[1] = uint32_t(bx::seek(_writer) - dxbcOffset); - size += write(_writer, DXBC_CHUNK_OUTPUT_SIGNATURE); - size += write(_writer, UINT32_C(0) ); - chunkSize[1] = write(_writer, _dxbc.outputSignature); + size += write(_writer, DXBC_CHUNK_OUTPUT_SIGNATURE, _err); + size += write(_writer, UINT32_C(0), _err); + chunkSize[1] = write(_writer, _dxbc.outputSignature, _err); chunkOffset[2] = uint32_t(bx::seek(_writer) - dxbcOffset); - size += write(_writer, _dxbc.shader.shex ? DXBC_CHUNK_SHADER_EX : DXBC_CHUNK_SHADER); - size += write(_writer, UINT32_C(0) ); - chunkSize[2] = write(_writer, _dxbc.shader); + size += write(_writer, _dxbc.shader.shex ? DXBC_CHUNK_SHADER_EX : DXBC_CHUNK_SHADER, _err); + size += write(_writer, UINT32_C(0), _err); + chunkSize[2] = write(_writer, _dxbc.shader, _err); size += 0 + chunkSize[0] @@ -1863,15 +1862,15 @@ namespace bgfx int64_t eof = bx::seek(_writer); bx::seek(_writer, sizeOffset, bx::Whence::Begin); - bx::write(_writer, size); + bx::write(_writer, size, _err); bx::seek(_writer, chunksOffsets, bx::Whence::Begin); - bx::write(_writer, chunkOffset, sizeof(chunkOffset) ); + bx::write(_writer, chunkOffset, sizeof(chunkOffset), _err); for (uint32_t ii = 0; ii < BX_COUNTOF(chunkOffset); ++ii) { bx::seek(_writer, chunkOffset[ii]+4, bx::Whence::Begin); - bx::write(_writer, chunkSize[ii]); + bx::write(_writer, chunkSize[ii], _err); } bx::seek(_writer, eof, bx::Whence::Begin); @@ -1879,14 +1878,16 @@ namespace bgfx return size; } - void parse(const DxbcShader& _src, DxbcParseFn _fn, void* _userData) + void parse(const DxbcShader& _src, DxbcParseFn _fn, void* _userData, bx::Error* _err) { + BX_ERROR_SCOPE(_err); + bx::MemoryReader reader(_src.byteCode.data(), uint32_t(_src.byteCode.size() ) ); for (uint32_t token = 0, numTokens = uint32_t(_src.byteCode.size() / sizeof(uint32_t) ); token < numTokens;) { DxbcInstruction instruction; - uint32_t size = read(&reader, instruction); + uint32_t size = read(&reader, instruction, _err); BX_CHECK(size/4 == instruction.length, "read %d, expected %d", size/4, instruction.length); BX_UNUSED(size); bool cont = _fn(token * sizeof(uint32_t), instruction, _userData); @@ -1899,8 +1900,10 @@ namespace bgfx } } - void filter(DxbcShader& _dst, const DxbcShader& _src, DxbcFilterFn _fn, void* _userData) + void filter(DxbcShader& _dst, const DxbcShader& _src, DxbcFilterFn _fn, void* _userData, bx::Error* _err) { + BX_ERROR_SCOPE(_err); + bx::MemoryReader reader(_src.byteCode.data(), uint32_t(_src.byteCode.size() ) ); bx::MemoryBlock mb(g_allocator); @@ -1909,12 +1912,12 @@ namespace bgfx for (uint32_t token = 0, numTokens = uint32_t(_src.byteCode.size() / sizeof(uint32_t) ); token < numTokens;) { DxbcInstruction instruction; - uint32_t size = read(&reader, instruction); + uint32_t size = read(&reader, instruction, _err); BX_CHECK(size/4 == instruction.length, "read %d, expected %d", size/4, instruction.length); BX_UNUSED(size); _fn(instruction, _userData); - write(&writer, instruction); + write(&writer, instruction, _err); token += instruction.length; } diff --git a/3rdparty/bgfx/src/shader_dxbc.h b/3rdparty/bgfx/src/shader_dxbc.h index 4aa3420fd89..381fd2f79cc 100644 --- a/3rdparty/bgfx/src/shader_dxbc.h +++ b/3rdparty/bgfx/src/shader_dxbc.h @@ -540,8 +540,8 @@ namespace bgfx DxbcOperand operand[6]; }; - int32_t read(bx::ReaderI* _reader, DxbcInstruction& _instruction); - int32_t write(bx::WriterI* _writer, const DxbcInstruction& _instruction); + int32_t read(bx::ReaderI* _reader, DxbcInstruction& _instruction, bx::Error* _err); + int32_t write(bx::WriterI* _writer, const DxbcInstruction& _instruction, bx::Error* _err); int32_t toString(char* _out, int32_t _size, const DxbcInstruction& _instruction); struct DxbcSignature @@ -562,8 +562,8 @@ namespace bgfx stl::vector<Element> elements; }; - int32_t read(bx::ReaderSeekerI* _reader, DxbcSignature& _signature); - int32_t write(bx::WriterI* _writer, const DxbcSignature& _signature); + int32_t read(bx::ReaderSeekerI* _reader, DxbcSignature& _signature, bx::Error* _err); + int32_t write(bx::WriterI* _writer, const DxbcSignature& _signature, bx::Error* _err); struct DxbcShader { @@ -572,14 +572,14 @@ namespace bgfx bool shex; }; - int32_t read(bx::ReaderSeekerI* _reader, DxbcShader& _shader); - int32_t write(bx::WriterI* _writer, const DxbcShader& _shader); + int32_t read(bx::ReaderSeekerI* _reader, DxbcShader& _shader, bx::Error* _err); + int32_t write(bx::WriterI* _writer, const DxbcShader& _shader, bx::Error* _err); typedef bool (*DxbcParseFn)(uint32_t _offset, const DxbcInstruction& _instruction, void* _userData); - void parse(const DxbcShader& _src, DxbcParseFn _fn, void* _userData); + void parse(const DxbcShader& _src, DxbcParseFn _fn, void* _userData, bx::Error* _err = NULL); typedef void (*DxbcFilterFn)(DxbcInstruction& _instruction, void* _userData); - void filter(DxbcShader& _dst, const DxbcShader& _src, DxbcFilterFn _fn, void* _userData); + void filter(DxbcShader& _dst, const DxbcShader& _src, DxbcFilterFn _fn, void* _userData, bx::Error* _err = NULL); struct DxbcContext { @@ -598,8 +598,8 @@ namespace bgfx DxbcShader shader; }; - int32_t read(bx::ReaderSeekerI* _reader, DxbcContext& _dxbc); - int32_t write(bx::WriterSeekerI* _writer, const DxbcContext& _dxbc); + int32_t read(bx::ReaderSeekerI* _reader, DxbcContext& _dxbc, bx::Error* _err); + int32_t write(bx::WriterSeekerI* _writer, const DxbcContext& _dxbc, bx::Error* _err); /// Calculate DXBC hash from data. void dxbcHash(const void* _data, uint32_t _size, void* _digest); diff --git a/3rdparty/bgfx/src/shader_spirv.cpp b/3rdparty/bgfx/src/shader_spirv.cpp index 63a8b0aa1d7..2fec1c0b0e4 100644 --- a/3rdparty/bgfx/src/shader_spirv.cpp +++ b/3rdparty/bgfx/src/shader_spirv.cpp @@ -8,303 +8,387 @@ namespace bgfx { - struct SpirvOpcodeInfo + struct SpvOpcodeInfo { - uint8_t numOperands; - uint8_t numValues; - bool hasVariable; + bool hasType; + bool hasResult; + SpvOperand::Enum operands[8]; }; - static const SpirvOpcodeInfo s_sprivOpcodeInfo[] = + static const SpvOpcodeInfo s_spvOpcodeInfo[] = { - { 0, 0, false }, // Nop, - { 0, 0, true }, // Source - { 0, 0, true }, // SourceExtension - { 0, 0, false }, // Extension - { 0, 1, true }, // ExtInstImport - { 0, 2, false }, // MemoryModel - { 0, 2, false }, // EntryPoint - { 0, 0, false }, // ExecutionMode - { 0, 1, false }, // TypeVoid - { 0, 1, false }, // TypeBool - { 0, 3, false }, // TypeInt - { 0, 2, false }, // TypeFloat - { 0, 3, false }, // TypeVector - { 0, 3, false }, // TypeMatrix - { 1, 7, false }, // TypeSampler - { 0, 0, false }, // TypeFilter - { 0, 0, false }, // TypeArray - { 0, 0, false }, // TypeRuntimeArray - { 0, 0, false }, // TypeStruct - { 0, 0, false }, // TypeOpaque - { 0, 3, false }, // TypePointer - { 0, 2, true }, // TypeFunction - { 0, 0, false }, // TypeEvent - { 0, 0, false }, // TypeDeviceEvent - { 0, 0, false }, // TypeReserveId - { 0, 0, false }, // TypeQueue - { 0, 0, false }, // TypePipe - { 0, 0, false }, // ConstantTrue - { 0, 0, false }, // ConstantFalse - { 0, 2, true }, // Constant - { 0, 2, true }, // ConstantComposite - { 0, 0, false }, // ConstantSampler - { 0, 0, false }, // ConstantNullPointer - { 0, 0, false }, // ConstantNullObject - { 0, 0, false }, // SpecConstantTrue - { 0, 0, false }, // SpecConstantFalse - { 0, 0, false }, // SpecConstant - { 0, 0, false }, // SpecConstantComposite - { 0, 3, true }, // Variable - { 0, 0, false }, // VariableArray - { 0, 4, false }, // Function - { 0, 0, false }, // FunctionParameter - { 0, 0, false }, // FunctionEnd - { 0, 0, false }, // FunctionCall - { 0, 0, false }, // ExtInst - { 0, 0, false }, // Undef - { 0, 0, false }, // Load - { 0, 2, true }, // Store - { 0, 0, false }, // Phi - { 0, 0, false }, // DecorationGroup - { 0, 2, true }, // Decorate - { 0, 0, false }, // MemberDecorate - { 0, 0, false }, // GroupDecorate - { 0, 0, false }, // GroupMemberDecorate - { 0, 1, true }, // Name - { 0, 1, true }, // MemberName - { 0, 0, false }, // String - { 0, 0, false }, // Line - { 0, 0, false }, // VectorExtractDynamic - { 0, 0, false }, // VectorInsertDynamic - { 0, 0, false }, // VectorShuffle - { 0, 0, false }, // CompositeConstruct - { 0, 0, false }, // CompositeExtract - { 0, 0, false }, // CompositeInsert - { 0, 0, false }, // CopyObject - { 0, 0, false }, // CopyMemory - { 0, 0, false }, // CopyMemorySized - { 0, 0, false }, // Sampler - { 0, 0, false }, // TextureSample - { 0, 0, false }, // TextureSampleDref - { 0, 0, false }, // TextureSampleLod - { 0, 0, false }, // TextureSampleProj - { 0, 0, false }, // TextureSampleGrad - { 0, 0, false }, // TextureSampleOffset - { 0, 0, false }, // TextureSampleProjLod - { 0, 0, false }, // TextureSampleProjGrad - { 0, 0, false }, // TextureSampleLodOffset - { 0, 0, false }, // TextureSampleProjOffset - { 0, 0, false }, // TextureSampleGradOffset - { 0, 0, false }, // TextureSampleProjLodOffset - { 0, 0, false }, // TextureSampleProjGradOffset - { 0, 0, false }, // TextureFetchTexelLod - { 0, 0, false }, // TextureFetchTexelOffset - { 0, 0, false }, // TextureFetchSample - { 0, 0, false }, // TextureFetchTexel - { 0, 0, false }, // TextureGather - { 0, 0, false }, // TextureGatherOffset - { 0, 0, false }, // TextureGatherOffsets - { 0, 0, false }, // TextureQuerySizeLod - { 0, 0, false }, // TextureQuerySize - { 0, 0, false }, // TextureQueryLod - { 0, 0, false }, // TextureQueryLevels - { 0, 0, false }, // TextureQuerySamples - { 0, 0, false }, // AccessChain - { 0, 0, false }, // InBoundsAccessChain - { 0, 0, false }, // SNegate - { 0, 0, false }, // FNegate - { 0, 0, false }, // Not - { 0, 0, false }, // Any - { 0, 0, false }, // All - { 0, 0, false }, // ConvertFToU - { 0, 0, false }, // ConvertFToS - { 0, 0, false }, // ConvertSToF - { 0, 0, false }, // ConvertUToF - { 0, 0, false }, // UConvert - { 0, 0, false }, // SConvert - { 0, 0, false }, // FConvert - { 0, 0, false }, // ConvertPtrToU - { 0, 0, false }, // ConvertUToPtr - { 0, 0, false }, // PtrCastToGeneric - { 0, 0, false }, // GenericCastToPtr - { 0, 0, false }, // Bitcast - { 0, 0, false }, // Transpose - { 0, 0, false }, // IsNan - { 0, 0, false }, // IsInf - { 0, 0, false }, // IsFinite - { 0, 0, false }, // IsNormal - { 0, 0, false }, // SignBitSet - { 0, 0, false }, // LessOrGreater - { 0, 0, false }, // Ordered - { 0, 0, false }, // Unordered - { 0, 0, false }, // ArrayLength - { 0, 0, false }, // IAdd - { 0, 0, false }, // FAdd - { 0, 0, false }, // ISub - { 0, 0, false }, // FSub - { 0, 0, false }, // IMul - { 0, 0, false }, // FMul - { 0, 0, false }, // UDiv - { 0, 0, false }, // SDiv - { 0, 0, false }, // FDiv - { 0, 0, false }, // UMod - { 0, 0, false }, // SRem - { 0, 0, false }, // SMod - { 0, 0, false }, // FRem - { 0, 0, false }, // FMod - { 0, 0, false }, // VectorTimesScalar - { 0, 0, false }, // MatrixTimesScalar - { 0, 0, false }, // VectorTimesMatrix - { 0, 0, false }, // MatrixTimesVector - { 0, 0, false }, // MatrixTimesMatrix - { 0, 0, false }, // OuterProduct - { 0, 0, false }, // Dot - { 0, 0, false }, // ShiftRightLogical - { 0, 0, false }, // ShiftRightArithmetic - { 0, 0, false }, // ShiftLeftLogical - { 0, 0, false }, // LogicalOr - { 0, 0, false }, // LogicalXor - { 0, 0, false }, // LogicalAnd - { 0, 0, false }, // BitwiseOr - { 0, 0, false }, // BitwiseXor - { 0, 0, false }, // BitwiseAnd - { 0, 0, false }, // Select - { 0, 0, false }, // IEqual - { 0, 0, false }, // FOrdEqual - { 0, 0, false }, // FUnordEqual - { 0, 0, false }, // INotEqual - { 0, 0, false }, // FOrdNotEqual - { 0, 0, false }, // FUnordNotEqual - { 0, 0, false }, // ULessThan - { 0, 0, false }, // SLessThan - { 0, 0, false }, // FOrdLessThan - { 0, 0, false }, // FUnordLessThan - { 0, 0, false }, // UGreaterThan - { 0, 0, false }, // SGreaterThan - { 0, 0, false }, // FOrdGreaterThan - { 0, 0, false }, // FUnordGreaterThan - { 0, 0, false }, // ULessThanEqual - { 0, 0, false }, // SLessThanEqual - { 0, 0, false }, // FOrdLessThanEqual - { 0, 0, false }, // FUnordLessThanEqual - { 0, 0, false }, // UGreaterThanEqual - { 0, 0, false }, // SGreaterThanEqual - { 0, 0, false }, // FOrdGreaterThanEqual - { 0, 0, false }, // FUnordGreaterThanEqual - { 0, 0, false }, // DPdx - { 0, 0, false }, // DPdy - { 0, 0, false }, // Fwidth - { 0, 0, false }, // DPdxFine - { 0, 0, false }, // DPdyFine - { 0, 0, false }, // FwidthFine - { 0, 0, false }, // DPdxCoarse - { 0, 0, false }, // DPdyCoarse - { 0, 0, false }, // FwidthCoarse - { 0, 0, false }, // EmitVertex - { 0, 0, false }, // EndPrimitive - { 0, 0, false }, // EmitStreamVertex - { 0, 0, false }, // EndStreamPrimitive - { 0, 0, false }, // ControlBarrier - { 0, 0, false }, // MemoryBarrier - { 0, 0, false }, // ImagePointer - { 0, 0, false }, // AtomicInit - { 0, 0, false }, // AtomicLoad - { 0, 0, false }, // AtomicStore - { 0, 0, false }, // AtomicExchange - { 0, 0, false }, // AtomicCompareExchange - { 0, 0, false }, // AtomicCompareExchangeWeak - { 0, 0, false }, // AtomicIIncrement - { 0, 0, false }, // AtomicIDecrement - { 0, 0, false }, // AtomicIAdd - { 0, 0, false }, // AtomicISub - { 0, 0, false }, // AtomicUMin - { 0, 0, false }, // AtomicUMax - { 0, 0, false }, // AtomicAnd - { 0, 0, false }, // AtomicOr - { 0, 0, false }, // AtomicXor - { 0, 0, false }, // LoopMerge - { 0, 0, false }, // SelectionMerge - { 0, 1, false }, // Label - { 0, 1, false }, // Branch - { 0, 0, false }, // BranchConditional - { 0, 0, false }, // Switch - { 0, 0, false }, // Kill - { 0, 0, false }, // Return - { 0, 0, false }, // ReturnValue - { 0, 0, false }, // Unreachable - { 0, 0, false }, // LifetimeStart - { 0, 0, false }, // LifetimeStop - { 0, 0, false }, // CompileFlag - { 0, 0, false }, // AsyncGroupCopy - { 0, 0, false }, // WaitGroupEvents - { 0, 0, false }, // GroupAll - { 0, 0, false }, // GroupAny - { 0, 0, false }, // GroupBroadcast - { 0, 0, false }, // GroupIAdd - { 0, 0, false }, // GroupFAdd - { 0, 0, false }, // GroupFMin - { 0, 0, false }, // GroupUMin - { 0, 0, false }, // GroupSMin - { 0, 0, false }, // GroupFMax - { 0, 0, false }, // GroupUMax - { 0, 0, false }, // GroupSMax - { 0, 0, false }, // GenericCastToPtrExplicit - { 0, 0, false }, // GenericPtrMemSemantics - { 0, 0, false }, // ReadPipe - { 0, 0, false }, // WritePipe - { 0, 0, false }, // ReservedReadPipe - { 0, 0, false }, // ReservedWritePipe - { 0, 0, false }, // ReserveReadPipePackets - { 0, 0, false }, // ReserveWritePipePackets - { 0, 0, false }, // CommitReadPipe - { 0, 0, false }, // CommitWritePipe - { 0, 0, false }, // IsValidReserveId - { 0, 0, false }, // GetNumPipePackets - { 0, 0, false }, // GetMaxPipePackets - { 0, 0, false }, // GroupReserveReadPipePackets - { 0, 0, false }, // GroupReserveWritePipePackets - { 0, 0, false }, // GroupCommitReadPipe - { 0, 0, false }, // GroupCommitWritePipe - { 0, 0, false }, // EnqueueMarker - { 0, 0, false }, // EnqueueKernel - { 0, 0, false }, // GetKernelNDrangeSubGroupCount - { 0, 0, false }, // GetKernelNDrangeMaxSubGroupSize - { 0, 0, false }, // GetKernelWorkGroupSize - { 0, 0, false }, // GetKernelPreferredWorkGroupSizeMultiple - { 0, 0, false }, // RetainEvent - { 0, 0, false }, // ReleaseEvent - { 0, 0, false }, // CreateUserEvent - { 0, 0, false }, // IsValidEvent - { 0, 0, false }, // SetUserEventStatus - { 0, 0, false }, // CaptureEventProfilingInfo - { 0, 0, false }, // GetDefaultQueue - { 0, 0, false }, // BuildNDRange - { 0, 0, false }, // SatConvertSToU - { 0, 0, false }, // SatConvertUToS - { 0, 0, false }, // AtomicIMin - { 0, 0, false }, // AtomicIMax +#define SPV_OPERAND_1(_a0) SpvOperand::_a0 +#define SPV_OPERAND_2(_a0, _a1) SPV_OPERAND_1(_a0), SPV_OPERAND_1(_a1) +#define SPV_OPERAND_3(_a0, _a1, _a2) SPV_OPERAND_1(_a0), SPV_OPERAND_2(_a1, _a2) +#define SPV_OPERAND_4(_a0, _a1, _a2, _a3) SPV_OPERAND_1(_a0), SPV_OPERAND_3(_a1, _a2, _a3) +#define SPV_OPERAND_5(_a0, _a1, _a2, _a3, _a4) SPV_OPERAND_1(_a0), SPV_OPERAND_4(_a1, _a2, _a3, _a4) +#define SPV_OPERAND_6(_a0, _a1, _a2, _a3, _a4, _a5) SPV_OPERAND_1(_a0), SPV_OPERAND_5(_a1, _a2, _a3, _a4, _a5) +#define SPV_OPERAND_7(_a0, _a1, _a2, _a3, _a4, _a5, _a6) SPV_OPERAND_1(_a0), SPV_OPERAND_6(_a1, _a2, _a3, _a4, _a5, _a6) +#define SPV_OPERAND_8(_a0, _a1, _a2, _a3, _a4, _a5, _a6, _a7) SPV_OPERAND_1(_a0), SPV_OPERAND_7(_a1, _a2, _a3, _a4, _a5, _a6, _a7) +#define SPV_OPERAND_9(_a0, _a1, _a2, _a3, _a4, _a5, _a6, _a7, _a8) SPV_OPERAND_1(_a0), SPV_OPERAND_8(_a1, _a2, _a3, _a4, _a5, _a6, _a7, _a8) +#if BX_COMPILER_MSVC +// Workaround MSVS bug... +# define SPV_OPERAND(...) { BX_MACRO_DISPATCHER(SPV_OPERAND_, __VA_ARGS__) BX_VA_ARGS_PASS(__VA_ARGS__) } +#else +# define SPV_OPERAND(...) { BX_MACRO_DISPATCHER(SPV_OPERAND_, __VA_ARGS__)(__VA_ARGS__) } +#endif // BX_COMPILER_MSVC +#define _ Count + { false, false, /* Nop, // 0 */ SPV_OPERAND(_) }, + { true, true, /* Undef, // 1 */ SPV_OPERAND(_) }, + { false, false, /* SourceContinued, // 2 */ SPV_OPERAND(_) }, + { false, false, /* Source, // 3 */ SPV_OPERAND(SourceLanguage, LiteralNumber, Id, LiteralString) }, + { false, false, /* SourceExtension, // 4 */ SPV_OPERAND(LiteralString) }, + { false, true, /* Name, // 5 */ SPV_OPERAND(LiteralString) }, + { false, true, /* MemberName, // 6 */ SPV_OPERAND(LiteralNumber, LiteralString) }, + { false, false, /* String, // 7 */ SPV_OPERAND(_) }, + { false, false, /* Line, // 8 */ SPV_OPERAND(_) }, + { false, false, /* ------------------------------- Invalid9 // 9 */ SPV_OPERAND(_) }, + { false, false, /* Extension, // 10 */ SPV_OPERAND(LiteralString) }, + { false, true, /* ExtInstImport, // 11 */ SPV_OPERAND(LiteralString) }, + { true, true, /* ExtInst, // 12 */ SPV_OPERAND(LiteralNumber) }, + { false, false, /* ------------------------------ Invalid13 // 13 */ SPV_OPERAND(_) }, + { false, false, /* MemoryModel, // 14 */ SPV_OPERAND(AddressingModel, MemoryModel) }, + { false, false, /* EntryPoint, // 15 */ SPV_OPERAND(ExecutionModel, Id, LiteralString) }, + { true, true, /* ExecutionMode, // 16 */ SPV_OPERAND(_) }, + { false, false, /* Capability, // 17 */ SPV_OPERAND(Capability ) }, + { false, false, /* ------------------------------ Invalid18 // 18 */ SPV_OPERAND(_) }, + { false, true, /* TypeVoid, // 19 */ SPV_OPERAND(LiteralNumber) }, + { false, true, /* TypeBool, // 20 */ SPV_OPERAND(LiteralNumber) }, + { false, true, /* TypeInt, // 21 */ SPV_OPERAND(LiteralNumber) }, + { false, true, /* TypeFloat, // 22 */ SPV_OPERAND(LiteralNumber) }, + { false, true, /* TypeVector, // 23 */ SPV_OPERAND(ComponentType, LiteralNumber) }, + { false, true, /* TypeMatrix, // 24 */ SPV_OPERAND(LiteralNumber) }, + { false, true, /* TypeImage, // 25 */ SPV_OPERAND(SampledType, Dim, LiteralNumber, LiteralNumber, LiteralNumber, LiteralNumber, ImageFormat, AccessQualifier) }, + { false, true, /* TypeSampler, // 26 */ SPV_OPERAND(LiteralNumber) }, + { false, true, /* TypeSampledImage, // 27 */ SPV_OPERAND(LiteralNumber) }, + { false, true, /* TypeArray, // 28 */ SPV_OPERAND(LiteralNumber) }, + { false, true, /* TypeRuntimeArray, // 29 */ SPV_OPERAND(_) }, + { false, true, /* TypeStruct, // 30 */ SPV_OPERAND(_) }, + { false, true, /* TypeOpaque, // 31 */ SPV_OPERAND(_) }, + { false, true, /* TypePointer, // 32 */ SPV_OPERAND(StorageClass, Id) }, + { false, true, /* TypeFunction, // 33 */ SPV_OPERAND(Id, Id, Id, Id, Id) }, + { false, true, /* TypeEvent, // 34 */ SPV_OPERAND(_) }, + { false, true, /* TypeDeviceEvent, // 35 */ SPV_OPERAND(_) }, + { false, true, /* TypeReserveId, // 36 */ SPV_OPERAND(_) }, + { false, true, /* TypeQueue, // 37 */ SPV_OPERAND(_) }, + { false, true, /* TypePipe, // 38 */ SPV_OPERAND(_) }, + { false, true, /* TypeForwardPointer, // 39 */ SPV_OPERAND(_) }, + { false, false, /* ------------------------------ Invalid40 // 40 */ SPV_OPERAND(_) }, + { true, true, /* ConstantTrue, // 41 */ SPV_OPERAND(_) }, + { true, true, /* ConstantFalse, // 42 */ SPV_OPERAND(_) }, + { true, true, /* Constant, // 43 */ SPV_OPERAND(LiteralRep) }, + { true, true, /* ConstantComposite, // 44 */ SPV_OPERAND(LiteralRep) }, + { true, true, /* ConstantSampler, // 45 */ SPV_OPERAND(SamplerAddressingMode, LiteralNumber, SamplerFilterMode) }, + { true, true, /* ConstantNull, // 46 */ SPV_OPERAND(_) }, + { false, false, /* ------------------------------ Invalid47 // 47 */ SPV_OPERAND(_) }, + { true, true, /* SpecConstantTrue, // 48 */ SPV_OPERAND(_) }, + { true, true, /* SpecConstantFalse, // 49 */ SPV_OPERAND(_) }, + { true, true, /* SpecConstant, // 50 */ SPV_OPERAND(_) }, + { true, true, /* SpecConstantComposite, // 51 */ SPV_OPERAND(_) }, + { true, true, /* SpecConstantOp, // 52 */ SPV_OPERAND(_) }, + { false, false, /* ------------------------------ Invalid53 // 53 */ SPV_OPERAND(_) }, + { true, true, /* Function, // 54 */ SPV_OPERAND(FunctionControl, Id) }, + { true, true, /* FunctionParameter, // 55 */ SPV_OPERAND(_) }, + { false, false, /* FunctionEnd, // 56 */ SPV_OPERAND(_) }, + { true, true, /* FunctionCall, // 57 */ SPV_OPERAND(Function, IdRep) }, + { false, false, /* ------------------------------ Invalid58 // 58 */ SPV_OPERAND(_) }, + { true, true, /* Variable, // 59 */ SPV_OPERAND(StorageClass, Id) }, + { true, true, /* ImageTexelPointer, // 60 */ SPV_OPERAND(_) }, + { true, true, /* Load, // 61 */ SPV_OPERAND(Pointer, MemoryAccess) }, + { false, false, /* Store, // 62 */ SPV_OPERAND(Pointer, Object, MemoryAccess) }, + { false, false, /* CopyMemory, // 63 */ SPV_OPERAND(_) }, + { false, false, /* CopyMemorySized, // 64 */ SPV_OPERAND(_) }, + { true, true, /* AccessChain, // 65 */ SPV_OPERAND(Base, IdRep) }, + { true, true, /* InBoundsAccessChain, // 66 */ SPV_OPERAND(Base, IdRep) }, + { true, true, /* PtrAccessChain, // 67 */ SPV_OPERAND(_) }, + { true, true, /* ArrayLength, // 68 */ SPV_OPERAND(_) }, + { true, true, /* GenericPtrMemSemantics, // 69 */ SPV_OPERAND(_) }, + { true, true, /* InBoundsPtrAccessChain, // 70 */ SPV_OPERAND(_) }, + { false, false, /* Decorate, // 71 */ SPV_OPERAND(Id, Decoration, LiteralRep) }, + { false, false, /* MemberDecorate, // 72 */ SPV_OPERAND(StructureType, LiteralNumber, Decoration, LiteralRep) }, + { false, false, /* DecorationGroup, // 73 */ SPV_OPERAND(_) }, + { false, false, /* GroupDecorate, // 74 */ SPV_OPERAND(_) }, + { false, false, /* GroupMemberDecorate, // 75 */ SPV_OPERAND(_) }, + { false, false, /* ------------------------------ Invalid76 // 76 */ SPV_OPERAND(_) }, + { true, true, /* VectorExtractDynamic, // 77 */ SPV_OPERAND(_) }, + { true, true, /* VectorInsertDynamic, // 78 */ SPV_OPERAND(_) }, + { true, true, /* VectorShuffle, // 79 */ SPV_OPERAND(Id, Id, LiteralRep) }, + { true, true, /* CompositeConstruct, // 80 */ SPV_OPERAND(IdRep) }, + { true, true, /* CompositeExtract, // 81 */ SPV_OPERAND(Composite, LiteralRep) }, + { true, true, /* CompositeInsert, // 82 */ SPV_OPERAND(Id, Composite, LiteralRep) }, + { true, true, /* CopyObject, // 83 */ SPV_OPERAND(Id) }, + { true, true, /* Transpose, // 84 */ SPV_OPERAND(Matrix) }, + { false, false, /* ------------------------------ Invalid85 // 85 */ SPV_OPERAND(_) }, + { true, true, /* SampledImage, // 86 */ SPV_OPERAND(_) }, + { true, true, /* ImageSampleImplicitLod, // 87 */ SPV_OPERAND(SampledImage, Coordinate, ImageOperands, IdRep) }, + { true, true, /* ImageSampleExplicitLod, // 88 */ SPV_OPERAND(SampledImage, Coordinate, ImageOperands, Id, IdRep) }, + { true, true, /* ImageSampleDrefImplicitLod, // 89 */ SPV_OPERAND(_) }, + { true, true, /* ImageSampleDrefExplicitLod, // 90 */ SPV_OPERAND(_) }, + { true, true, /* ImageSampleProjImplicitLod, // 91 */ SPV_OPERAND(_) }, + { true, true, /* ImageSampleProjExplicitLod, // 92 */ SPV_OPERAND(_) }, + { true, true, /* ImageSampleProjDrefImplicitLod, // 93 */ SPV_OPERAND(_) }, + { true, true, /* ImageSampleProjDrefExplicitLod, // 94 */ SPV_OPERAND(_) }, + { true, true, /* ImageFetch, // 95 */ SPV_OPERAND(_) }, + { true, true, /* ImageGather, // 96 */ SPV_OPERAND(SampledImage, Coordinate, Component, ImageOperands, IdRep) }, + { true, true, /* ImageDrefGather, // 97 */ SPV_OPERAND(SampledImage, Coordinate, Dref, ImageOperands, IdRep) }, + { true, true, /* ImageRead, // 98 */ SPV_OPERAND(_) }, + { false, false, /* ImageWrite, // 99 */ SPV_OPERAND(_) }, + { true, true, /* Image, // 100 */ SPV_OPERAND(_) }, + { true, true, /* ImageQueryFormat, // 101 */ SPV_OPERAND(_) }, + { true, true, /* ImageQueryOrder, // 102 */ SPV_OPERAND(_) }, + { true, true, /* ImageQuerySizeLod, // 103 */ SPV_OPERAND(_) }, + { true, true, /* ImageQuerySize, // 104 */ SPV_OPERAND(_) }, + { true, true, /* ImageQueryLod, // 105 */ SPV_OPERAND(_) }, + { true, true, /* ImageQueryLevels, // 106 */ SPV_OPERAND(_) }, + { true, true, /* ImageQuerySamples, // 107 */ SPV_OPERAND(_) }, + { false, false, /* ----------------------------- Invalid108 // 108 */ SPV_OPERAND(_) }, + { true, true, /* ConvertFToU, // 109 */ SPV_OPERAND(_) }, + { true, true, /* ConvertFToS, // 110 */ SPV_OPERAND(_) }, + { true, true, /* ConvertSToF, // 111 */ SPV_OPERAND(_) }, + { true, true, /* ConvertUToF, // 112 */ SPV_OPERAND(_) }, + { true, true, /* UConvert, // 113 */ SPV_OPERAND(Id) }, + { true, true, /* SConvert, // 114 */ SPV_OPERAND(Id) }, + { true, true, /* FConvert, // 115 */ SPV_OPERAND(Id) }, + { true, true, /* QuantizeToF16, // 116 */ SPV_OPERAND(_) }, + { true, true, /* ConvertPtrToU, // 117 */ SPV_OPERAND(_) }, + { true, true, /* SatConvertSToU, // 118 */ SPV_OPERAND(_) }, + { true, true, /* SatConvertUToS, // 119 */ SPV_OPERAND(_) }, + { true, true, /* ConvertUToPtr, // 120 */ SPV_OPERAND(_) }, + { true, true, /* PtrCastToGeneric, // 121 */ SPV_OPERAND(_) }, + { true, true, /* GenericCastToPtr, // 122 */ SPV_OPERAND(_) }, + { true, true, /* GenericCastToPtrExplicit, // 123 */ SPV_OPERAND(_) }, + { true, true, /* Bitcast, // 124 */ SPV_OPERAND(_) }, + { false, false, /* ----------------------------- Invalid125 // 125 */ SPV_OPERAND(_) }, + { true, true, /* SNegate, // 126 */ SPV_OPERAND(Id) }, + { true, true, /* FNegate, // 127 */ SPV_OPERAND(Id) }, + { true, true, /* IAdd, // 128 */ SPV_OPERAND(Id, Id) }, + { true, true, /* FAdd, // 129 */ SPV_OPERAND(Id, Id) }, + { true, true, /* ISub, // 130 */ SPV_OPERAND(Id, Id) }, + { true, true, /* FSub, // 131 */ SPV_OPERAND(Id, Id) }, + { true, true, /* IMul, // 132 */ SPV_OPERAND(Id, Id) }, + { true, true, /* FMul, // 133 */ SPV_OPERAND(Id, Id) }, + { true, true, /* UDiv, // 134 */ SPV_OPERAND(Id, Id) }, + { true, true, /* SDiv, // 135 */ SPV_OPERAND(Id, Id) }, + { true, true, /* FDiv, // 136 */ SPV_OPERAND(Id, Id) }, + { true, true, /* UMod, // 137 */ SPV_OPERAND(Id, Id) }, + { true, true, /* SRem, // 138 */ SPV_OPERAND(Id, Id) }, + { true, true, /* SMod, // 139 */ SPV_OPERAND(Id, Id) }, + { true, true, /* FRem, // 140 */ SPV_OPERAND(Id, Id) }, + { true, true, /* FMod, // 141 */ SPV_OPERAND(Id, Id) }, + { true, true, /* VectorTimesScalar, // 142 */ SPV_OPERAND(Vector, Scalar) }, + { true, true, /* MatrixTimesScalar, // 143 */ SPV_OPERAND(Matrix, Scalar) }, + { true, true, /* VectorTimesMatrix, // 144 */ SPV_OPERAND(Vector, Matrix) }, + { true, true, /* MatrixTimesVector, // 145 */ SPV_OPERAND(Matrix, Vector) }, + { true, true, /* MatrixTimesMatrix, // 146 */ SPV_OPERAND(Matrix, Matrix) }, + { true, true, /* OuterProduct, // 147 */ SPV_OPERAND(Vector, Vector) }, + { true, true, /* Dot, // 148 */ SPV_OPERAND(Vector, Vector) }, + { true, true, /* IAddCarry, // 149 */ SPV_OPERAND(Id, Id) }, + { true, true, /* ISubBorrow, // 150 */ SPV_OPERAND(Id, Id) }, + { true, true, /* UMulExtended, // 151 */ SPV_OPERAND(Id, Id) }, + { true, true, /* SMulExtended, // 152 */ SPV_OPERAND(Id, Id) }, + { false, false, /* ----------------------------- Invalid153 // 153 */ SPV_OPERAND(_) }, + { true, true, /* Any, // 154 */ SPV_OPERAND(Vector) }, + { true, true, /* All, // 155 */ SPV_OPERAND(Vector) }, + { true, true, /* IsNan, // 156 */ SPV_OPERAND(Id) }, + { true, true, /* IsInf, // 157 */ SPV_OPERAND(Id) }, + { true, true, /* IsFinite, // 158 */ SPV_OPERAND(Id) }, + { true, true, /* IsNormal, // 159 */ SPV_OPERAND(Id) }, + { true, true, /* SignBitSet, // 160 */ SPV_OPERAND(Id) }, + { true, true, /* LessOrGreater, // 161 */ SPV_OPERAND(Id, Id) }, + { true, true, /* Ordered, // 162 */ SPV_OPERAND(Id, Id) }, + { true, true, /* Unordered, // 163 */ SPV_OPERAND(_) }, + { true, true, /* LogicalEqual, // 164 */ SPV_OPERAND(_) }, + { true, true, /* LogicalNotEqual, // 165 */ SPV_OPERAND(_) }, + { true, true, /* LogicalOr, // 166 */ SPV_OPERAND(_) }, + { true, true, /* LogicalAnd, // 167 */ SPV_OPERAND(_) }, + { true, true, /* LogicalNot, // 168 */ SPV_OPERAND(_) }, + { true, true, /* Select, // 169 */ SPV_OPERAND(Condition, Id, Id) }, + { true, true, /* IEqual, // 170 */ SPV_OPERAND(_) }, + { true, true, /* INotEqual, // 171 */ SPV_OPERAND(_) }, + { true, true, /* UGreaterThan, // 172 */ SPV_OPERAND(_) }, + { true, true, /* SGreaterThan, // 173 */ SPV_OPERAND(_) }, + { true, true, /* UGreaterThanEqual, // 174 */ SPV_OPERAND(_) }, + { true, true, /* SGreaterThanEqual, // 175 */ SPV_OPERAND(_) }, + { true, true, /* ULessThan, // 176 */ SPV_OPERAND(_) }, + { true, true, /* SLessThan, // 177 */ SPV_OPERAND(_) }, + { true, true, /* ULessThanEqual, // 178 */ SPV_OPERAND(_) }, + { true, true, /* SLessThanEqual, // 179 */ SPV_OPERAND(_) }, + { true, true, /* FOrdEqual, // 180 */ SPV_OPERAND(_) }, + { true, true, /* FUnordEqual, // 181 */ SPV_OPERAND(_) }, + { true, true, /* FOrdNotEqual, // 182 */ SPV_OPERAND(_) }, + { true, true, /* FUnordNotEqual, // 183 */ SPV_OPERAND(_) }, + { true, true, /* FOrdLessThan, // 184 */ SPV_OPERAND(_) }, + { true, true, /* FUnordLessThan, // 185 */ SPV_OPERAND(_) }, + { true, true, /* FOrdGreaterThan, // 186 */ SPV_OPERAND(_) }, + { true, true, /* FUnordGreaterThan, // 187 */ SPV_OPERAND(_) }, + { true, true, /* FOrdLessThanEqual, // 188 */ SPV_OPERAND(_) }, + { true, true, /* FUnordLessThanEqual, // 189 */ SPV_OPERAND(_) }, + { true, true, /* FOrdGreaterThanEqual, // 190 */ SPV_OPERAND(_) }, + { true, true, /* FUnordGreaterThanEqual, // 191 */ SPV_OPERAND(_) }, + { false, false, /* ----------------------------- Invalid192 // 192 */ SPV_OPERAND(_) }, + { false, false, /* ----------------------------- Invalid193 // 193 */ SPV_OPERAND(_) }, + { true, true, /* ShiftRightLogical, // 194 */ SPV_OPERAND(_) }, + { true, true, /* ShiftRightArithmetic, // 195 */ SPV_OPERAND(_) }, + { true, true, /* ShiftLeftLogical, // 196 */ SPV_OPERAND(_) }, + { true, true, /* BitwiseOr, // 197 */ SPV_OPERAND(_) }, + { true, true, /* BitwiseXor, // 198 */ SPV_OPERAND(_) }, + { true, true, /* BitwiseAnd, // 199 */ SPV_OPERAND(_) }, + { true, true, /* Not, // 200 */ SPV_OPERAND(_) }, + { true, true, /* BitFieldInsert, // 201 */ SPV_OPERAND(_) }, + { true, true, /* BitFieldSExtract, // 202 */ SPV_OPERAND(_) }, + { true, true, /* BitFieldUExtract, // 203 */ SPV_OPERAND(_) }, + { true, true, /* BitReverse, // 204 */ SPV_OPERAND(_) }, + { true, true, /* BitCount, // 205 */ SPV_OPERAND(_) }, + { false, false, /* ----------------------------- Invalid206 // 206 */ SPV_OPERAND(_) }, + { true, true, /* DPdx, // 207 */ SPV_OPERAND(_) }, + { true, true, /* DPdy, // 208 */ SPV_OPERAND(_) }, + { true, true, /* Fwidth, // 209 */ SPV_OPERAND(_) }, + { true, true, /* DPdxFine, // 210 */ SPV_OPERAND(_) }, + { true, true, /* DPdyFine, // 211 */ SPV_OPERAND(_) }, + { true, true, /* FwidthFine, // 212 */ SPV_OPERAND(_) }, + { true, true, /* DPdxCoarse, // 213 */ SPV_OPERAND(_) }, + { true, true, /* DPdyCoarse, // 214 */ SPV_OPERAND(_) }, + { true, true, /* FwidthCoarse, // 215 */ SPV_OPERAND(_) }, + { false, false, /* ----------------------------- Invalid216 // 216 */ SPV_OPERAND(_) }, + { false, false, /* ----------------------------- Invalid217 // 217 */ SPV_OPERAND(_) }, + { false, false, /* EmitVertex, // 218 */ SPV_OPERAND(_) }, + { false, false, /* EndPrimitive, // 219 */ SPV_OPERAND(_) }, + { false, false, /* EmitStreamVertex, // 220 */ SPV_OPERAND(_) }, + { false, false, /* EndStreamPrimitive, // 221 */ SPV_OPERAND(_) }, + { false, false, /* ----------------------------- Invalid222 // 222 */ SPV_OPERAND(_) }, + { false, false, /* ----------------------------- Invalid223 // 223 */ SPV_OPERAND(_) }, + { false, false, /* ControlBarrier, // 224 */ SPV_OPERAND(_) }, + { false, false, /* MemoryBarrier, // 225 */ SPV_OPERAND(_) }, + { false, false, /* ----------------------------- Invalid226 // 226 */ SPV_OPERAND(_) }, + { true, true, /* AtomicLoad, // 227 */ SPV_OPERAND(_) }, + { false, false, /* AtomicStore, // 228 */ SPV_OPERAND(_) }, + { true, true, /* AtomicExchange, // 229 */ SPV_OPERAND(_) }, + { true, true, /* AtomicCompareExchange, // 230 */ SPV_OPERAND(_) }, + { true, true, /* AtomicCompareExchangeWeak, // 231 */ SPV_OPERAND(_) }, + { true, true, /* AtomicIIncrement, // 232 */ SPV_OPERAND(_) }, + { true, true, /* AtomicIDecrement, // 233 */ SPV_OPERAND(_) }, + { true, true, /* AtomicIAdd, // 234 */ SPV_OPERAND(_) }, + { true, true, /* AtomicISub, // 235 */ SPV_OPERAND(_) }, + { true, true, /* AtomicSMin, // 236 */ SPV_OPERAND(_) }, + { true, true, /* AtomicUMin, // 237 */ SPV_OPERAND(_) }, + { true, true, /* AtomicSMax, // 238 */ SPV_OPERAND(_) }, + { true, true, /* AtomicUMax, // 239 */ SPV_OPERAND(_) }, + { true, true, /* AtomicAnd, // 240 */ SPV_OPERAND(_) }, + { true, true, /* AtomicOr, // 241 */ SPV_OPERAND(_) }, + { true, true, /* AtomicXor, // 242 */ SPV_OPERAND(_) }, + { false, false, /* ----------------------------- Invalid243 // 243 */ SPV_OPERAND(_) }, + { false, false, /* ----------------------------- Invalid244 // 244 */ SPV_OPERAND(_) }, + { true, true, /* Phi, // 245 */ SPV_OPERAND(_) }, + { false, false, /* LoopMerge, // 246 */ SPV_OPERAND(_) }, + { false, false, /* SelectionMerge, // 247 */ SPV_OPERAND(_) }, + { false, true, /* Label, // 248 */ SPV_OPERAND(_) }, + { false, false, /* Branch, // 249 */ SPV_OPERAND(Id) }, + { false, false, /* BranchConditional, // 250 */ SPV_OPERAND(Condition, Id, Id, LiteralRep) }, + { false, false, /* Switch, // 251 */ SPV_OPERAND(_) }, + { false, false, /* Kill, // 252 */ SPV_OPERAND(_) }, + { false, false, /* Return, // 253 */ SPV_OPERAND(_) }, + { false, false, /* ReturnValue, // 254 */ SPV_OPERAND(Id) }, + { false, false, /* Unreachable, // 255 */ SPV_OPERAND(_) }, + { false, false, /* LifetimeStart, // 256 */ SPV_OPERAND(_) }, + { false, false, /* LifetimeStop, // 257 */ SPV_OPERAND(_) }, + { false, false, /* ----------------------------- Invalid258 // 258 */ SPV_OPERAND(_) }, + { true, true, /* GroupAsyncCopy, // 259 */ SPV_OPERAND(_) }, + { false, false, /* GroupWaitEvents, // 260 */ SPV_OPERAND(_) }, + { true, true, /* GroupAll, // 261 */ SPV_OPERAND(_) }, + { true, true, /* GroupAny, // 262 */ SPV_OPERAND(_) }, + { true, true, /* GroupBroadcast, // 263 */ SPV_OPERAND(_) }, + { true, true, /* GroupIAdd, // 264 */ SPV_OPERAND(_) }, + { true, true, /* GroupFAdd, // 265 */ SPV_OPERAND(_) }, + { true, true, /* GroupFMin, // 266 */ SPV_OPERAND(_) }, + { true, true, /* GroupUMin, // 267 */ SPV_OPERAND(_) }, + { true, true, /* GroupSMin, // 268 */ SPV_OPERAND(_) }, + { true, true, /* GroupFMax, // 269 */ SPV_OPERAND(_) }, + { true, true, /* GroupUMax, // 270 */ SPV_OPERAND(_) }, + { true, true, /* GroupSMax, // 271 */ SPV_OPERAND(_) }, + { false, false, /* ----------------------------- Invalid272 // 272 */ SPV_OPERAND(_) }, + { false, false, /* ----------------------------- Invalid273 // 273 */ SPV_OPERAND(_) }, + { true, true, /* ReadPipe, // 274 */ SPV_OPERAND(_) }, + { true, true, /* WritePipe, // 275 */ SPV_OPERAND(_) }, + { true, true, /* ReservedReadPipe, // 276 */ SPV_OPERAND(_) }, + { true, true, /* ReservedWritePipe, // 277 */ SPV_OPERAND(_) }, + { true, true, /* ReserveReadPipePackets, // 278 */ SPV_OPERAND(_) }, + { true, true, /* ReserveWritePipePackets, // 279 */ SPV_OPERAND(_) }, + { false, false, /* CommitReadPipe, // 280 */ SPV_OPERAND(_) }, + { false, false, /* CommitWritePipe, // 281 */ SPV_OPERAND(_) }, + { true, true, /* IsValidReserveId, // 282 */ SPV_OPERAND(_) }, + { true, true, /* GetNumPipePackets, // 283 */ SPV_OPERAND(_) }, + { true, true, /* GetMaxPipePackets, // 284 */ SPV_OPERAND(_) }, + { true, true, /* GroupReserveReadPipePackets, // 285 */ SPV_OPERAND(_) }, + { true, true, /* GroupReserveWritePipePackets, // 286 */ SPV_OPERAND(_) }, + { false, false, /* GroupCommitReadPipe, // 287 */ SPV_OPERAND(_) }, + { false, false, /* GroupCommitWritePipe, // 288 */ SPV_OPERAND(_) }, + { false, false, /* ----------------------------- Invalid289 // 289 */ SPV_OPERAND(_) }, + { false, false, /* ----------------------------- Invalid290 // 290 */ SPV_OPERAND(_) }, + { true, true, /* EnqueueMarker, // 291 */ SPV_OPERAND(_) }, + { true, true, /* EnqueueKernel, // 292 */ SPV_OPERAND(_) }, + { true, true, /* GetKernelNDrangeSubGroupCount, // 293 */ SPV_OPERAND(_) }, + { true, true, /* GetKernelNDrangeMaxSubGroupSize, // 294 */ SPV_OPERAND(_) }, + { true, true, /* GetKernelWorkGroupSize, // 295 */ SPV_OPERAND(_) }, + { true, true, /* GetKernelPreferredWorkGroupSizeMultiple, // 296 */ SPV_OPERAND(_) }, + { false, false, /* RetainEvent, // 297 */ SPV_OPERAND(_) }, + { false, false, /* ReleaseEvent, // 298 */ SPV_OPERAND(_) }, + { true, true, /* CreateUserEvent, // 299 */ SPV_OPERAND(_) }, + { true, true, /* IsValidEvent, // 300 */ SPV_OPERAND(_) }, + { false, false, /* SetUserEventStatus, // 301 */ SPV_OPERAND(_) }, + { false, false, /* CaptureEventProfilingInfo, // 302 */ SPV_OPERAND(_) }, + { true, true, /* GetDefaultQueue, // 303 */ SPV_OPERAND(_) }, + { true, true, /* BuildNDRange, // 304 */ SPV_OPERAND(_) }, + { true, true, /* ImageSparseSampleImplicitLod, // 305 */ SPV_OPERAND(_) }, + { true, true, /* ImageSparseSampleExplicitLod, // 306 */ SPV_OPERAND(_) }, + { true, true, /* ImageSparseSampleDrefImplicitLod, // 307 */ SPV_OPERAND(_) }, + { true, true, /* ImageSparseSampleDrefExplicitLod, // 308 */ SPV_OPERAND(_) }, + { true, true, /* ImageSparseSampleProjImplicitLod, // 309 */ SPV_OPERAND(_) }, + { true, true, /* ImageSparseSampleProjExplicitLod, // 310 */ SPV_OPERAND(_) }, + { true, true, /* ImageSparseSampleProjDrefImplicitLod, // 311 */ SPV_OPERAND(_) }, + { true, true, /* ImageSparseSampleProjDrefExplicitLod, // 312 */ SPV_OPERAND(_) }, + { true, true, /* ImageSparseFetch, // 313 */ SPV_OPERAND(_) }, + { true, true, /* ImageSparseGather, // 314 */ SPV_OPERAND(_) }, + { true, true, /* ImageSparseDrefGather, // 315 */ SPV_OPERAND(_) }, + { true, true, /* ImageSparseTexelsResident, // 316 */ SPV_OPERAND(_) }, + { false, false, /* NoLine, // 317 */ SPV_OPERAND(_) }, + { true, true, /* AtomicFlagTestAndSet, // 318 */ SPV_OPERAND(_) }, + { false, false, /* AtomicFlagClear, // 319 */ SPV_OPERAND(_) }, + { true, true, /* ImageSparseRead, // 320 */ SPV_OPERAND(_) }, +#undef _ +#undef SPV_OPERAND }; - BX_STATIC_ASSERT(BX_COUNTOF(s_sprivOpcodeInfo) == SpirvOpcode::Count); + BX_STATIC_ASSERT(BX_COUNTOF(s_spvOpcodeInfo) == SpvOpcode::Count); - const char* s_spirvOpcode[] = + const char* s_spvOpcode[] = { "Nop", + "Undef", + "SourceContinued", "Source", "SourceExtension", + "Name", + "MemberName", + "String", + "Line", + "Invalid9", "Extension", "ExtInstImport", + "ExtInst", + "Invalid13", "MemoryModel", "EntryPoint", "ExecutionMode", + "Capability", + "Invalid18", "TypeVoid", "TypeBool", "TypeInt", "TypeFloat", "TypeVector", "TypeMatrix", + "TypeImage", "TypeSampler", - "TypeFilter", + "TypeSampledImage", "TypeArray", "TypeRuntimeArray", "TypeStruct", @@ -316,37 +400,44 @@ namespace bgfx "TypeReserveId", "TypeQueue", "TypePipe", + "TypeForwardPointer", + "Invalid40", "ConstantTrue", "ConstantFalse", "Constant", "ConstantComposite", "ConstantSampler", - "ConstantNullPointer", - "ConstantNullObject", + "ConstantNull", + "Invalid47", "SpecConstantTrue", "SpecConstantFalse", "SpecConstant", "SpecConstantComposite", - "Variable", - "VariableArray", + "SpecConstantOp", + "Invalid53", "Function", "FunctionParameter", "FunctionEnd", "FunctionCall", - "ExtInst", - "Undef", + "Invalid58", + "Variable", + "ImageTexelPointer", "Load", "Store", - "Phi", - "DecorationGroup", + "CopyMemory", + "CopyMemorySized", + "AccessChain", + "InBoundsAccessChain", + "PtrAccessChain", + "ArrayLength", + "GenericPtrMemSemantics", + "InBoundsPtrAccessChain", "Decorate", "MemberDecorate", + "DecorationGroup", "GroupDecorate", "GroupMemberDecorate", - "Name", - "MemberName", - "String", - "Line", + "Invalid76", "VectorExtractDynamic", "VectorInsertDynamic", "VectorShuffle", @@ -354,41 +445,31 @@ namespace bgfx "CompositeExtract", "CompositeInsert", "CopyObject", - "CopyMemory", - "CopyMemorySized", - "Sampler", - "TextureSample", - "TextureSampleDref", - "TextureSampleLod", - "TextureSampleProj", - "TextureSampleGrad", - "TextureSampleOffset", - "TextureSampleProjLod", - "TextureSampleProjGrad", - "TextureSampleLodOffset", - "TextureSampleProjOffset", - "TextureSampleGradOffset", - "TextureSampleProjLodOffset", - "TextureSampleProjGradOffset", - "TextureFetchTexelLod", - "TextureFetchTexelOffset", - "TextureFetchSample", - "TextureFetchTexel", - "TextureGather", - "TextureGatherOffset", - "TextureGatherOffsets", - "TextureQuerySizeLod", - "TextureQuerySize", - "TextureQueryLod", - "TextureQueryLevels", - "TextureQuerySamples", - "AccessChain", - "InBoundsAccessChain", - "SNegate", - "FNegate", - "Not", - "Any", - "All", + "Transpose", + "Invalid85", + "SampledImage", + "ImageSampleImplicitLod", + "ImageSampleExplicitLod", + "ImageSampleDrefImplicitLod", + "ImageSampleDrefExplicitLod", + "ImageSampleProjImplicitLod", + "ImageSampleProjExplicitLod", + "ImageSampleProjDrefImplicitLod", + "ImageSampleProjDrefExplicitLod", + "ImageFetch", + "ImageGather", + "ImageDrefGather", + "ImageRead", + "ImageWrite", + "Image", + "ImageQueryFormat", + "ImageQueryOrder", + "ImageQuerySizeLod", + "ImageQuerySize", + "ImageQueryLod", + "ImageQueryLevels", + "ImageQuerySamples", + "Invalid108", "ConvertFToU", "ConvertFToS", "ConvertSToF", @@ -396,21 +477,18 @@ namespace bgfx "UConvert", "SConvert", "FConvert", + "QuantizeToF16", "ConvertPtrToU", + "SatConvertSToU", + "SatConvertUToS", "ConvertUToPtr", "PtrCastToGeneric", "GenericCastToPtr", + "GenericCastToPtrExplicit", "Bitcast", - "Transpose", - "IsNan", - "IsInf", - "IsFinite", - "IsNormal", - "SignBitSet", - "LessOrGreater", - "Ordered", - "Unordered", - "ArrayLength", + "Invalid125", + "SNegate", + "FNegate", "IAdd", "FAdd", "ISub", @@ -432,38 +510,64 @@ namespace bgfx "MatrixTimesMatrix", "OuterProduct", "Dot", - "ShiftRightLogical", - "ShiftRightArithmetic", - "ShiftLeftLogical", + "IAddCarry", + "ISubBorrow", + "UMulExtended", + "SMulExtended", + "Invalid153", + "Any", + "All", + "IsNan", + "IsInf", + "IsFinite", + "IsNormal", + "SignBitSet", + "LessOrGreater", + "Ordered", + "Unordered", + "LogicalEqual", + "LogicalNotEqual", "LogicalOr", - "LogicalXor", "LogicalAnd", - "BitwiseOr", - "BitwiseXor", - "BitwiseAnd", + "LogicalNot", "Select", "IEqual", + "INotEqual", + "UGreaterThan", + "SGreaterThan", + "UGreaterThanEqual", + "SGreaterThanEqual", + "ULessThan", + "SLessThan", + "ULessThanEqual", + "SLessThanEqual", "FOrdEqual", "FUnordEqual", - "INotEqual", "FOrdNotEqual", "FUnordNotEqual", - "ULessThan", - "SLessThan", "FOrdLessThan", "FUnordLessThan", - "UGreaterThan", - "SGreaterThan", "FOrdGreaterThan", "FUnordGreaterThan", - "ULessThanEqual", - "SLessThanEqual", "FOrdLessThanEqual", "FUnordLessThanEqual", - "UGreaterThanEqual", - "SGreaterThanEqual", "FOrdGreaterThanEqual", "FUnordGreaterThanEqual", + "Invalid192", + "Invalid193", + "ShiftRightLogical", + "ShiftRightArithmetic", + "ShiftLeftLogical", + "BitwiseOr", + "BitwiseXor", + "BitwiseAnd", + "Not", + "BitFieldInsert", + "BitFieldSExtract", + "BitFieldUExtract", + "BitReverse", + "BitCount", + "Invalid206", "DPdx", "DPdy", "Fwidth", @@ -473,14 +577,17 @@ namespace bgfx "DPdxCoarse", "DPdyCoarse", "FwidthCoarse", + "Invalid216", + "Invalid217", "EmitVertex", "EndPrimitive", "EmitStreamVertex", + "Invalid222", + "Invalid223", "EndStreamPrimitive", "ControlBarrier", "MemoryBarrier", - "ImagePointer", - "AtomicInit", + "Invalid226", "AtomicLoad", "AtomicStore", "AtomicExchange", @@ -490,11 +597,16 @@ namespace bgfx "AtomicIDecrement", "AtomicIAdd", "AtomicISub", + "AtomicSMin", "AtomicUMin", + "AtomicSMax", "AtomicUMax", "AtomicAnd", "AtomicOr", "AtomicXor", + "Invalid243", + "Invalid244", + "Phi", "LoopMerge", "SelectionMerge", "Label", @@ -507,9 +619,9 @@ namespace bgfx "Unreachable", "LifetimeStart", "LifetimeStop", - "CompileFlag", - "AsyncGroupCopy", - "WaitGroupEvents", + "Invalid258", + "GroupAsyncCopy", + "GroupWaitEvents", "GroupAll", "GroupAny", "GroupBroadcast", @@ -521,8 +633,8 @@ namespace bgfx "GroupFMax", "GroupUMax", "GroupSMax", - "GenericCastToPtrExplicit", - "GenericPtrMemSemantics", + "Invalid272", + "Invalid273", "ReadPipe", "WritePipe", "ReservedReadPipe", @@ -538,6 +650,8 @@ namespace bgfx "GroupReserveWritePipePackets", "GroupCommitReadPipe", "GroupCommitWritePipe", + "Invalid289", + "Invalid290", "EnqueueMarker", "EnqueueKernel", "GetKernelNDrangeSubGroupCount", @@ -552,170 +666,318 @@ namespace bgfx "CaptureEventProfilingInfo", "GetDefaultQueue", "BuildNDRange", - "SatConvertSToU", - "SatConvertUToS", - "AtomicIMin", - "AtomicIMax", + "ImageSparseSampleImplicitLod", + "ImageSparseSampleExplicitLod", + "ImageSparseSampleDrefImplicitLod", + "ImageSparseSampleDrefExplicitLod", + "ImageSparseSampleProjImplicitLod", + "ImageSparseSampleProjExplicitLod", + "ImageSparseSampleProjDrefImplicitLod", + "ImageSparseSampleProjDrefExplicitLod", + "ImageSparseFetch", + "ImageSparseGather", + "ImageSparseDrefGather", + "ImageSparseTexelsResident", + "NoLine", + "AtomicFlagTestAndSet", + "AtomicFlagClear", + "ImageSparseRead", + }; + BX_STATIC_ASSERT(BX_COUNTOF(s_spvOpcode) == SpvOpcode::Count); + + const char* getName(SpvOpcode::Enum _opcode) + { + BX_WARN(_opcode < SpvOpcode::Count, "Unknown opcode id %d.", _opcode); + return _opcode < SpvOpcode::Count + ? s_spvOpcode[_opcode] + : "?SpvOpcode?" + ; + } + + static const char* s_spvStorageClass[] = + { + "UniformConstant", + "Input", + "Uniform", + "Output", + "Workgroup", + "CrossWorkgroup", + "Private", + "Function", + "Generic", + "PushConstant", + "AtomicCounter", + "Image", }; - BX_STATIC_ASSERT(BX_COUNTOF(s_spirvOpcode) == SpirvOpcode::Count); + BX_STATIC_ASSERT(BX_COUNTOF(s_spvStorageClass) == SpvStorageClass::Count); - const char* getName(SpirvOpcode::Enum _opcode) + const char* getName(SpvStorageClass::Enum _enum) { - BX_CHECK(_opcode < SpirvOpcode::Count, "Unknown opcode id %d.", _opcode); - return s_spirvOpcode[_opcode]; + BX_CHECK(_enum < SpvStorageClass::Count, "Unknown storage class id %d.", _enum); + return _enum < SpvStorageClass::Count + ? s_spvStorageClass[_enum] + : "?SpvStorageClass?" + ; } - int32_t read(bx::ReaderI* _reader, SpirvOperand& _operand) + int32_t read(bx::ReaderI* _reader, SpvOperand& _operand, bx::Error* _err) { int32_t size = 0; - BX_UNUSED(_operand); uint32_t token; - size += bx::read(_reader, token); + _operand.literalString = ""; + + switch (_operand.type) + { + case SpvOperand::LiteralString: + do + { + size += bx::read(_reader, token, _err); + _operand.literalString.append( (char*)&token, (char*)&token + sizeof(token) ); + } + while (0 != (token & 0xff000000) && _err->isOk() ); + break; + + default: + size += bx::read(_reader, _operand.data[0], _err); + break; + } return size; } - int32_t read(bx::ReaderI* _reader, SpirvInstruction& _instruction) + int32_t read(bx::ReaderI* _reader, SpvInstruction& _instruction, bx::Error* _err) { int32_t size = 0; uint32_t token; - size += bx::read(_reader, token); + size += bx::read(_reader, token, _err); + + _instruction.opcode = SpvOpcode::Enum( (token & UINT32_C(0x0000ffff) ) ); + _instruction.length = uint16_t( (token & UINT32_C(0xffff0000) ) >> 16); - _instruction.opcode = SpirvOpcode::Enum( (token & UINT32_C(0x0000ffff) ) ); - _instruction.length = uint16_t( (token & UINT32_C(0xffff0000) ) >> 16); + if (_instruction.opcode >= SpvOpcode::Count) + { + BX_ERROR_SET(_err, BGFX_SHADER_SPIRV_INVALID_INSTRUCTION, "SPIR-V: Invalid instruction."); + return size; + } - uint32_t currOp = 0; + if (0 == _instruction.length) + { + return size; + } - const SpirvOpcodeInfo& info = s_sprivOpcodeInfo[_instruction.opcode]; + const SpvOpcodeInfo& info = s_spvOpcodeInfo[_instruction.opcode]; + _instruction.hasType = info.hasType; + _instruction.hasResult = info.hasResult; - if (0 < info.numValues) + if (info.hasType) { - size += read(_reader, _instruction.un.value, info.numValues*sizeof(uint32_t) ); + size += read(_reader, _instruction.type, _err); } - if (info.hasVariable) + if (info.hasResult) { - while (size/4 != _instruction.length) - { - uint32_t tmp; - size += bx::read(_reader, tmp); - } + size += read(_reader, _instruction.result, _err); } - else + + uint16_t currOp = 0; + switch (_instruction.opcode) { - _instruction.numOperands = info.numOperands; - switch (info.numOperands) + case SpvOpcode::EntryPoint: + _instruction.operand[currOp].type = info.operands[currOp]; + size += read(_reader, _instruction.operand[currOp++], _err); + _instruction.operand[currOp].type = info.operands[currOp]; + size += read(_reader, _instruction.operand[currOp++], _err); + _instruction.operand[currOp].type = info.operands[currOp]; + size += read(_reader, _instruction.operand[currOp++], _err); + + _instruction.operand[currOp].type = SpvOperand::Id; + for (uint32_t ii = 0, num = _instruction.length - size/4; ii < num; ++ii) { - case 6: size += read(_reader, _instruction.operand[currOp++]); - case 5: size += read(_reader, _instruction.operand[currOp++]); - case 4: size += read(_reader, _instruction.operand[currOp++]); - case 3: size += read(_reader, _instruction.operand[currOp++]); - case 2: size += read(_reader, _instruction.operand[currOp++]); - case 1: size += read(_reader, _instruction.operand[currOp++]); - case 0: - break; - - default: - BX_WARN(false, "Instruction %s with invalid number of operands %d (numValues %d)." - , getName(_instruction.opcode) - , info.numOperands - , info.numValues - ); - break; + size += read(_reader, _instruction.operand[currOp], _err); } + break; - BX_WARN(size/4 == _instruction.length, "read %d, expected %d, %s" - , size/4 - , _instruction.length - , getName(_instruction.opcode) - ); - while (size/4 != _instruction.length) + default: + for (;size/4 != _instruction.length && _err->isOk(); ++currOp) { - uint32_t tmp; - size += bx::read(_reader, tmp); + _instruction.operand[currOp].type = info.operands[currOp]; + size += read(_reader, _instruction.operand[currOp], _err); } + break; } + _instruction.numOperands = currOp; + return size; } - int32_t write(bx::WriterI* _writer, const SpirvInstruction& _instruction) + int32_t write(bx::WriterI* _writer, const SpvInstruction& _instruction, bx::Error* _err) { int32_t size = 0; - BX_UNUSED(_writer, _instruction); + BX_UNUSED(_writer, _instruction, _err); return size; } - int32_t toString(char* _out, int32_t _size, const SpirvInstruction& _instruction) + int32_t toString(char* _out, int32_t _size, const SpvInstruction& _instruction) { int32_t size = 0; + + if (_instruction.hasResult) + { + size += bx::snprintf(&_out[size], bx::uint32_imax(0, _size-size) + , " %%%d = " + , _instruction.result + ); + } + size += bx::snprintf(&_out[size], bx::uint32_imax(0, _size-size) - , "%s %d (%d, %d)" + , "%s" , getName(_instruction.opcode) - , _instruction.numOperands - , _instruction.un.value[0] - , _instruction.un.value[1] ); + for (uint32_t ii = 0, num = _instruction.numOperands; ii < num; ++ii) + { + const SpvOperand& operand = _instruction.operand[ii]; + switch (operand.type) + { + case SpvOperand::AddressingModel: + size += bx::snprintf(&_out[size], bx::uint32_imax(0, _size-size) + , "%sAddressingModel(%d)" + , 0 == ii ? " " : ", " + , operand.data[0] + ); + break; + + case SpvOperand::FunctionControl: + size += bx::snprintf(&_out[size], bx::uint32_imax(0, _size-size) + , "%s0x%08x" + , 0 == ii ? " " : ", " + , operand.data[0] + ); + break; + + case SpvOperand::LiteralNumber: + size += bx::snprintf(&_out[size], bx::uint32_imax(0, _size-size) + , "%s%d" + , 0 == ii ? " " : ", " + , operand.data[0] + ); + break; + + case SpvOperand::LiteralString: + size += bx::snprintf(&_out[size], bx::uint32_imax(0, _size-size) + , "%s%s" + , 0 == ii ? " " : ", " + , operand.literalString.c_str() + ); + break; + + case SpvOperand::MemoryModel: + size += bx::snprintf(&_out[size], bx::uint32_imax(0, _size-size) + , "%sMemoryModel(%d)" + , 0 == ii ? " " : ", " + , operand.data[0] + ); + break; + + case SpvOperand::StorageClass: + size += bx::snprintf(&_out[size], bx::uint32_imax(0, _size-size) + , "%s%s" + , 0 == ii ? " " : ", " + , getName(SpvStorageClass::Enum(operand.data[0]) ) + ); + break; + + case SpvOperand::Count: + size += bx::snprintf(&_out[size], bx::uint32_imax(0, _size-size) + , "%s__%d__" + , 0 == ii ? " " : ", " + , operand.data[0] + ); + break; + + default: + size += bx::snprintf(&_out[size], bx::uint32_imax(0, _size-size) + , "%s%%%d" + , 0 == ii ? " " : ", " + , operand.data[0] + ); + break; + + } + } + return size; } - int32_t read(bx::ReaderSeekerI* _reader, SpirvShader& _shader) + int32_t read(bx::ReaderSeekerI* _reader, SpvShader& _shader, bx::Error* _err) { int32_t size = 0; - uint32_t len = uint32_t(bx::getSize(_reader) - bx::seek(_reader) ); - _shader.byteCode.resize(len); - size += bx::read(_reader, _shader.byteCode.data(), len); + uint32_t numBytes = uint32_t(bx::getSize(_reader) - bx::seek(_reader) ); + _shader.byteCode.resize(numBytes); + size += bx::read(_reader, _shader.byteCode.data(), numBytes, _err); return size; } - int32_t write(bx::WriterI* _writer, const SpirvShader& _shader) + int32_t write(bx::WriterI* _writer, const SpvShader& _shader, bx::Error* _err) { int32_t size = 0; - BX_UNUSED(_writer, _shader); + BX_UNUSED(_writer, _shader, _err); return size; } #define SPIRV_MAGIC 0x07230203 - int32_t read(bx::ReaderSeekerI* _reader, Spirv& _spirv) + int32_t read(bx::ReaderSeekerI* _reader, SpirV& _spirv, bx::Error* _err) { + BX_ERROR_SCOPE(_err); + int32_t size = 0; - size += bx::read(_reader, _spirv.header); + size += bx::read(_reader, _spirv.header, _err); - if (size != sizeof(Spirv::Header) + if (!_err->isOk() + || size != sizeof(SpirV::Header) || _spirv.header.magic != SPIRV_MAGIC ) { - // error - return -size; + BX_ERROR_SET(_err, BGFX_SHADER_SPIRV_INVALID_HEADER, "SPIR-V: Invalid header."); + return size; } - size += read(_reader, _spirv.shader); + size += read(_reader, _spirv.shader, _err); return size; } - int32_t write(bx::WriterSeekerI* _writer, const Spirv& _spirv) + int32_t write(bx::WriterSeekerI* _writer, const SpirV& _spirv, bx::Error* _err) { int32_t size = 0; - BX_UNUSED(_writer, _spirv); + BX_UNUSED(_writer, _spirv, _err); return size; } - void parse(const SpirvShader& _src, SpirvParseFn _fn, void* _userData) + void parse(const SpvShader& _src, SpirvParseFn _fn, void* _userData, bx::Error* _err) { - bx::MemoryReader reader(_src.byteCode.data(), uint32_t(_src.byteCode.size() ) ); + BX_ERROR_SCOPE(_err); + + uint32_t numBytes = uint32_t(_src.byteCode.size() ); + bx::MemoryReader reader(_src.byteCode.data(), numBytes); for (uint32_t token = 0, numTokens = uint32_t(_src.byteCode.size() / sizeof(uint32_t) ); token < numTokens;) { - SpirvInstruction instruction; - uint32_t size = read(&reader, instruction); + SpvInstruction instruction; + uint32_t size = read(&reader, instruction, _err); + + if (!_err->isOk() ) + { + return; + } + BX_CHECK(size/4 == instruction.length, "read %d, expected %d, %s" , size/4 , instruction.length @@ -723,7 +985,11 @@ namespace bgfx ); BX_UNUSED(size); - _fn(token * sizeof(uint32_t), instruction, _userData); + bool cont = _fn(token * sizeof(uint32_t), instruction, _userData); + if (!cont) + { + return; + } token += instruction.length; } diff --git a/3rdparty/bgfx/src/shader_spirv.h b/3rdparty/bgfx/src/shader_spirv.h index 73577e77030..9a7c81b1ac2 100644 --- a/3rdparty/bgfx/src/shader_spirv.h +++ b/3rdparty/bgfx/src/shader_spirv.h @@ -8,30 +8,45 @@ #include <bx/readerwriter.h> +BX_ERROR_RESULT(BGFX_SHADER_SPIRV_INVALID_HEADER, BX_MAKEFOURCC('S', 'H', 0, 1) ); +BX_ERROR_RESULT(BGFX_SHADER_SPIRV_INVALID_INSTRUCTION, BX_MAKEFOURCC('S', 'H', 0, 2) ); + namespace bgfx { // Reference: https://www.khronos.org/registry/spir-v/specs/1.0/SPIRV.html - struct SpirvOpcode + struct SpvOpcode { enum Enum { Nop, + Undef, + SourceContinued, Source, SourceExtension, + Name, + MemberName, + String, + Line, + Invalid9, Extension, ExtInstImport, + ExtInst, + Invalid13, MemoryModel, EntryPoint, ExecutionMode, + Capability, + Invalid18, TypeVoid, TypeBool, TypeInt, TypeFloat, TypeVector, TypeMatrix, + TypeImage, TypeSampler, - TypeFilter, + TypeSampledImage, TypeArray, TypeRuntimeArray, TypeStruct, @@ -43,37 +58,44 @@ namespace bgfx TypeReserveId, TypeQueue, TypePipe, + TypeForwardPointer, + Invalid40, ConstantTrue, ConstantFalse, Constant, ConstantComposite, ConstantSampler, - ConstantNullPointer, - ConstantNullObject, + ConstantNull, + Invalid47, SpecConstantTrue, SpecConstantFalse, SpecConstant, SpecConstantComposite, - Variable, - VariableArray, + SpecConstantOp, + Invalid53, Function, FunctionParameter, FunctionEnd, FunctionCall, - ExtInst, - Undef, + Invalid58, + Variable, + ImageTexelPointer, Load, Store, - Phi, - DecorationGroup, + CopyMemory, + CopyMemorySized, + AccessChain, + InBoundsAccessChain, + PtrAccessChain, + ArrayLength, + GenericPtrMemSemantics, + InBoundsPtrAccessChain, Decorate, MemberDecorate, + DecorationGroup, GroupDecorate, GroupMemberDecorate, - Name, - MemberName, - String, - Line, + Invalid76, VectorExtractDynamic, VectorInsertDynamic, VectorShuffle, @@ -81,41 +103,31 @@ namespace bgfx CompositeExtract, CompositeInsert, CopyObject, - CopyMemory, - CopyMemorySized, - Sampler, - TextureSample, - TextureSampleDref, - TextureSampleLod, - TextureSampleProj, - TextureSampleGrad, - TextureSampleOffset, - TextureSampleProjLod, - TextureSampleProjGrad, - TextureSampleLodOffset, - TextureSampleProjOffset, - TextureSampleGradOffset, - TextureSampleProjLodOffset, - TextureSampleProjGradOffset, - TextureFetchTexelLod, - TextureFetchTexelOffset, - TextureFetchSample, - TextureFetchTexel, - TextureGather, - TextureGatherOffset, - TextureGatherOffsets, - TextureQuerySizeLod, - TextureQuerySize, - TextureQueryLod, - TextureQueryLevels, - TextureQuerySamples, - AccessChain, - InBoundsAccessChain, - SNegate, - FNegate, - Not, - Any, - All, + Transpose, + Invalid85, + SampledImage, + ImageSampleImplicitLod, + ImageSampleExplicitLod, + ImageSampleDrefImplicitLod, + ImageSampleDrefExplicitLod, + ImageSampleProjImplicitLod, + ImageSampleProjExplicitLod, + ImageSampleProjDrefImplicitLod, + ImageSampleProjDrefExplicitLod, + ImageFetch, + ImageGather, + ImageDrefGather, + ImageRead, + ImageWrite, + Image, + ImageQueryFormat, + ImageQueryOrder, + ImageQuerySizeLod, + ImageQuerySize, + ImageQueryLod, + ImageQueryLevels, + ImageQuerySamples, + Invalid108, ConvertFToU, ConvertFToS, ConvertSToF, @@ -123,21 +135,18 @@ namespace bgfx UConvert, SConvert, FConvert, + QuantizeToF16, ConvertPtrToU, + SatConvertSToU, + SatConvertUToS, ConvertUToPtr, PtrCastToGeneric, GenericCastToPtr, + GenericCastToPtrExplicit, Bitcast, - Transpose, - IsNan, - IsInf, - IsFinite, - IsNormal, - SignBitSet, - LessOrGreater, - Ordered, - Unordered, - ArrayLength, + Invalid125, + SNegate, + FNegate, IAdd, FAdd, ISub, @@ -159,38 +168,64 @@ namespace bgfx MatrixTimesMatrix, OuterProduct, Dot, - ShiftRightLogical, - ShiftRightArithmetic, - ShiftLeftLogical, + IAddCarry, + ISubBorrow, + UMulExtended, + SMulExtended, + Invalid153, + Any, + All, + IsNan, + IsInf, + IsFinite, + IsNormal, + SignBitSet, + LessOrGreater, + Ordered, + Unordered, + LogicalEqual, + LogicalNotEqual, LogicalOr, - LogicalXor, LogicalAnd, - BitwiseOr, - BitwiseXor, - BitwiseAnd, + LogicalNot, Select, IEqual, + INotEqual, + UGreaterThan, + SGreaterThan, + UGreaterThanEqual, + SGreaterThanEqual, + ULessThan, + SLessThan, + ULessThanEqual, + SLessThanEqual, FOrdEqual, FUnordEqual, - INotEqual, FOrdNotEqual, FUnordNotEqual, - ULessThan, - SLessThan, FOrdLessThan, FUnordLessThan, - UGreaterThan, - SGreaterThan, FOrdGreaterThan, FUnordGreaterThan, - ULessThanEqual, - SLessThanEqual, FOrdLessThanEqual, FUnordLessThanEqual, - UGreaterThanEqual, - SGreaterThanEqual, FOrdGreaterThanEqual, FUnordGreaterThanEqual, + Invalid192, + Invalid193, + ShiftRightLogical, + ShiftRightArithmetic, + ShiftLeftLogical, + BitwiseOr, + BitwiseXor, + BitwiseAnd, + Not, + BitFieldInsert, + BitFieldSExtract, + BitFieldUExtract, + BitReverse, + BitCount, + Invalid206, DPdx, DPdy, Fwidth, @@ -200,14 +235,17 @@ namespace bgfx DPdxCoarse, DPdyCoarse, FwidthCoarse, + Invalid216, + Invalid217, EmitVertex, EndPrimitive, EmitStreamVertex, EndStreamPrimitive, + Invalid222, + Invalid223, ControlBarrier, MemoryBarrier, - ImagePointer, - AtomicInit, + Invalid226, AtomicLoad, AtomicStore, AtomicExchange, @@ -217,11 +255,16 @@ namespace bgfx AtomicIDecrement, AtomicIAdd, AtomicISub, + AtomicSMin, AtomicUMin, + AtomicSMax, AtomicUMax, AtomicAnd, AtomicOr, AtomicXor, + Invalid243, + Invalid244, + Phi, LoopMerge, SelectionMerge, Label, @@ -234,9 +277,9 @@ namespace bgfx Unreachable, LifetimeStart, LifetimeStop, - CompileFlag, - AsyncGroupCopy, - WaitGroupEvents, + Invalid258, + GroupAsyncCopy, + GroupWaitEvents, GroupAll, GroupAny, GroupBroadcast, @@ -248,8 +291,8 @@ namespace bgfx GroupFMax, GroupUMax, GroupSMax, - GenericCastToPtrExplicit, - GenericPtrMemSemantics, + Invalid272, + Invalid273, ReadPipe, WritePipe, ReservedReadPipe, @@ -265,6 +308,8 @@ namespace bgfx GroupReserveWritePipePackets, GroupCommitReadPipe, GroupCommitWritePipe, + Invalid289, + Invalid290, EnqueueMarker, EnqueueKernel, GetKernelNDrangeSubGroupCount, @@ -279,10 +324,22 @@ namespace bgfx CaptureEventProfilingInfo, GetDefaultQueue, BuildNDRange, - SatConvertSToU, - SatConvertUToS, - AtomicIMin, - AtomicIMax, + ImageSparseSampleImplicitLod, + ImageSparseSampleExplicitLod, + ImageSparseSampleDrefImplicitLod, + ImageSparseSampleDrefExplicitLod, + ImageSparseSampleProjImplicitLod, + ImageSparseSampleProjExplicitLod, + ImageSparseSampleProjDrefImplicitLod, + ImageSparseSampleProjDrefExplicitLod, + ImageSparseFetch, + ImageSparseGather, + ImageSparseDrefGather, + ImageSparseTexelsResident, + NoLine, + AtomicFlagTestAndSet, + AtomicFlagClear, + ImageSparseRead, Count }; @@ -294,12 +351,11 @@ namespace bgfx { Position, PointSize, - ClipVertex, ClipDistance, CullDistance, VertexId, InstanceId, - BuiltInPrimitiveId, + PrimitiveId, InvocationId, Layer, ViewportIndex, @@ -313,7 +369,6 @@ namespace bgfx SampleId, SamplePosition, SampleMask, - FragColor, FragDepth, HelperInvocation, NumWorkgroups, @@ -327,17 +382,20 @@ namespace bgfx EnqueuedWorkgroupSize, GlobalOffset, GlobalLinearId, - WorkgroupLinearId, SubgroupSize, SubgroupMaxSize, NumSubgroups, NumEnqueuedSubgroups, SubgroupId, SubgroupLocalInvocationId, + VertexIndex, + InstanceIndex, + + Count }; }; - struct SpirvExecutionModel + struct SpvExecutionModel { enum Enum { @@ -353,21 +411,31 @@ namespace bgfx }; }; - struct SpirvMemoryModel + struct SpvAddressingModel + { + enum Enum + { + Logical, + Physical32, + Physical64, + + Count + }; + }; + + struct SpvMemoryModel { enum Enum { Simple, GLSL450, - OpenCL12, - OpenCL20, - OpenCL21, + OpenCL, Count }; }; - struct SpirvStorageClass + struct SpvStorageClass { enum Enum { @@ -375,17 +443,20 @@ namespace bgfx Input, Uniform, Output, - WorkgroupLocal, - WorkgroupGlobal, - PrivateGlobal, + Workgroup, + CrossWorkgroup, + Private, Function, Generic, - Private, + PushConstant, AtomicCounter, + Image, + + Count }; }; - struct SpirvResourceDim + struct SpvResourceDim { enum Enum { @@ -395,26 +466,27 @@ namespace bgfx TextureCube, TextureRect, Buffer, + SubpassData, }; }; - struct SpirvDecoration + struct SpvDecoration { enum Enum { - PrecisionLow, - PrecisionMedium, - PrecisionHigh, + RelaxedPrecision, + SpecId, Block, BufferBlock, RowMajor, ColMajor, + ArrayStride, + MatrixStride, GLSLShared, - GLSLStd140, - GLSLStd430, GLSLPacked, - Smooth, - Noperspective, + CPacked, + BuiltIn, + NoPerspective, Flat, Patch, Centroid, @@ -425,11 +497,9 @@ namespace bgfx Volatile, Constant, Coherent, - Nonwritable, - Nonreadable, + NonWritable, + NonReadable, Uniform, - NoStaticUse, - CPacked, SaturatedConversion, Stream, Location, @@ -438,66 +508,104 @@ namespace bgfx Binding, DescriptorSet, Offset, - Alignment, XfbBuffer, - Stride, - BuiltIn, + XfbStride, FuncParamAttr, FPRoundingMode, FPFastMathMode, LinkageAttributes, - SpecId, + NoContraction, + InputAttachmentIndex, + Alignment, Count }; }; - struct SpirvOperand + struct SpvOperand { + enum Enum + { + AccessQualifier, + AddressingModel, + Base, + Capability, + Component, + ComponentType, + Composite, + Condition, + Coordinate, + Decoration, + Dim, + Dref, + ExecutionModel, + Function, + FunctionControl, + Id, + IdRep, + ImageFormat, + ImageOperands, + LiteralNumber, + LiteralRep, + LiteralString, + Matrix, + MemoryAccess, + MemoryModel, + Object, + Pointer, + SampledType, + SampledImage, + SamplerAddressingMode, + SamplerFilterMode, + Scalar, + SourceLanguage, + StorageClass, + StructureType, + Vector, + + Count + }; + + Enum type; + uint32_t data[4]; + + uint32_t target; + stl::string literalString; }; - struct SpirvInstruction + struct SpvInstruction { - SpirvOpcode::Enum opcode; + SpvOpcode::Enum opcode; uint16_t length; + uint16_t numOperands; - uint8_t numOperands; - SpirvOperand operand[6]; - - union - { - struct ResultTypeId - { - uint32_t resultType; - uint32_t id; - }; - - ResultTypeId constant; - ResultTypeId constantComposite; + uint32_t type; + uint32_t result; + bool hasType; + bool hasResult; - uint32_t value[8]; - } un; + SpvOperand operand[8]; }; - int32_t read(bx::ReaderI* _reader, SpirvInstruction& _instruction); - int32_t write(bx::WriterI* _writer, const SpirvInstruction& _instruction); - int32_t toString(char* _out, int32_t _size, const SpirvInstruction& _instruction); + int32_t read(bx::ReaderI* _reader, SpvInstruction& _instruction, bx::Error* _err); + int32_t write(bx::WriterI* _writer, const SpvInstruction& _instruction, bx::Error* _err); + int32_t toString(char* _out, int32_t _size, const SpvInstruction& _instruction); - struct SpirvShader + struct SpvShader { stl::vector<uint8_t> byteCode; }; - int32_t read(bx::ReaderSeekerI* _reader, SpirvShader& _shader); - int32_t write(bx::WriterI* _writer, const SpirvShader& _shader); + int32_t read(bx::ReaderSeekerI* _reader, SpvShader& _shader, bx::Error* _err); + int32_t write(bx::WriterI* _writer, const SpvShader& _shader, bx::Error* _err); - typedef void (*SpirvParseFn)(uint32_t _offset, const SpirvInstruction& _instruction, void* _userData); - void parse(const SpirvShader& _src, SpirvParseFn _fn, void* _userData); + typedef bool (*SpirvParseFn)(uint32_t _offset, const SpvInstruction& _instruction, void* _userData); + void parse(const SpvShader& _src, SpirvParseFn _fn, void* _userData, bx::Error* _err = NULL); - typedef void (*SpirvFilterFn)(SpirvInstruction& _instruction, void* _userData); - void filter(SpirvShader& _dst, const SpirvShader& _src, SpirvFilterFn _fn, void* _userData); + typedef void (*SpirvFilterFn)(SpvInstruction& _instruction, void* _userData); + void filter(SpvShader& _dst, const SpvShader& _src, SpirvFilterFn _fn, void* _userData, bx::Error* _err = NULL); - struct Spirv + struct SpirV { struct Header { @@ -509,11 +617,11 @@ namespace bgfx }; Header header; - SpirvShader shader; + SpvShader shader; }; - int32_t read(bx::ReaderSeekerI* _reader, Spirv& _spirv); - int32_t write(bx::WriterSeekerI* _writer, const Spirv& _spirv); + int32_t read(bx::ReaderSeekerI* _reader, SpirV& _spirv, bx::Error* _err); + int32_t write(bx::WriterSeekerI* _writer, const SpirV& _spirv, bx::Error* _err); } // namespace bgfx diff --git a/3rdparty/bgfx/src/topology.cpp b/3rdparty/bgfx/src/topology.cpp new file mode 100644 index 00000000000..767e4995772 --- /dev/null +++ b/3rdparty/bgfx/src/topology.cpp @@ -0,0 +1,216 @@ +/* + * Copyright 2011-2016 Branimir Karadzic. All rights reserved. + * License: https://github.com/bkaradzic/bgfx#license-bsd-2-clause + */ + +#include <bx/debug.h> +#include <bx/allocator.h> +#include <bx/radixsort.h> + +#include "config.h" +#include "topology.h" + +namespace bgfx +{ + template<typename IndexT> + static uint32_t topologyConvertTriListFlipWinding(void* _dst, uint32_t _dstSize, const IndexT* _indices, uint32_t _numIndices) + { + if (NULL == _dst) + { + return _numIndices; + } + + IndexT* dst = (IndexT*)_dst; + IndexT* end = &dst[_dstSize/sizeof(IndexT)]; + for (uint32_t ii = 0; ii < _numIndices && dst < end; ii += 3, dst += 3) + { + const IndexT* tri = &_indices[ii]; + IndexT i0 = tri[0], i1 = tri[1], i2 = tri[2]; + + dst[0] = i0; + dst[1] = i2; + dst[2] = i1; + } + + return _numIndices; + } + + template<typename IndexT, typename SortT> + static uint32_t topologyConvertTriListToLineList(void* _dst, uint32_t _dstSize, const IndexT* _indices, uint32_t _numIndices, IndexT* _temp, SortT* _tempSort) + { + // Create all line pairs and sort indices. + IndexT* dst = _temp; + for (uint32_t ii = 0; ii < _numIndices; ii += 3) + { + const IndexT* tri = &_indices[ii]; + IndexT i0 = tri[0], i1 = tri[1], i2 = tri[2]; + + if (i0 > i1) { bx::xchg(i0, i1); } + if (i1 > i2) { bx::xchg(i1, i2); } + if (i0 > i1) { bx::xchg(i0, i1); } + BX_CHECK(i0 < i1 && i1 < i2, ""); + + dst[0] = i0; dst[1] = i1; + dst[2] = i1; dst[3] = i2; + dst[4] = i0; dst[5] = i2; + dst += 6; + } + + // Sort all line pairs. + SortT* sorted = (SortT*)_temp; + bx::radixSort(sorted, _tempSort, _numIndices); + + uint32_t num = 0; + + // Remove all line pair duplicates. + if (NULL == _dst) + { + SortT last = sorted[0]; + for (uint32_t ii = 1; ii < _numIndices; ++ii) + { + if (last != sorted[ii]) + { + num += 2; + last = sorted[ii]; + } + } + num += 2; + } + else + { + dst = (IndexT*)_dst; + IndexT* end = &dst[_dstSize/sizeof(IndexT)]; + SortT last = sorted[0]; + for (uint32_t ii = 1; ii < _numIndices && dst < end; ++ii) + { + if (last != sorted[ii]) + { + union Un { SortT key; struct { IndexT i0; IndexT i1; } u16; } un = { last }; + dst[0] = un.u16.i0; + dst[1] = un.u16.i1; + dst += 2; + last = sorted[ii]; + } + } + + if (dst < end) + { + union Un { SortT key; struct { IndexT i0; IndexT i1; } u16; } un = { last }; + dst[0] = un.u16.i0; + dst[1] = un.u16.i1; + dst += 2; + } + + num = uint32_t(dst - (IndexT*)_dst); + } + + return num; + } + + template<typename IndexT, typename SortT> + static uint32_t topologyConvertTriListToLineList(void* _dst, uint32_t _dstSize, const IndexT* _indices, uint32_t _numIndices, bx::AllocatorI* _allocator) + { + IndexT* temp = (IndexT*)BX_ALLOC(_allocator, _numIndices*2*sizeof(IndexT)*2); + SortT* tempSort = (SortT*)&temp[_numIndices*2]; + uint32_t num = topologyConvertTriListToLineList(_dst, _dstSize, _indices, _numIndices, temp, tempSort); + BX_FREE(_allocator, temp); + return num; + } + + template<typename IndexT> + static uint32_t topologyConvertTriStripToTriList(void* _dst, uint32_t _dstSize, const IndexT* _indices, uint32_t _numIndices) + { + IndexT* dst = (IndexT*)_dst; + IndexT* end = &dst[_dstSize/sizeof(IndexT)]; + + for (uint32_t ii = 0, num = _numIndices-2; ii < num && dst < end; ++ii) + { + IndexT i0 = _indices[ii+0]; + IndexT i1 = _indices[ii+1]; + IndexT i2 = _indices[ii+2]; + if (i0 != i1 + && i1 != i2) + { + dst[0] = i0; + dst[1] = i1; + dst[2] = i2; + dst += 3; + } + } + + return uint32_t(dst - (IndexT*)_dst); + } + + template<typename IndexT> + static uint32_t topologyConvertLineStripToLineList(void* _dst, uint32_t _dstSize, const IndexT* _indices, uint32_t _numIndices) + { + IndexT* dst = (IndexT*)_dst; + IndexT* end = &dst[_dstSize/sizeof(IndexT)]; + + IndexT i0 = _indices[0]; + + for (uint32_t ii = 1; ii < _numIndices && dst < end; ++ii) + { + IndexT i1 = _indices[ii]; + if (i0 != i1) + { + dst[0] = i0; + dst[1] = i1; + dst += 2; + + i0 = i1; + } + } + + return uint32_t(dst - (IndexT*)_dst); + } + + uint32_t topologyConvert(TopologyConvert::Enum _conversion, void* _dst, uint32_t _dstSize, const void* _indices, uint32_t _numIndices, bool _index32, bx::AllocatorI* _allocator) + { + switch (_conversion) + { + case TopologyConvert::TriStripToTriList: + if (_index32) + { + return topologyConvertTriStripToTriList(_dst, _dstSize, (const uint32_t*)_indices, _numIndices); + } + + return topologyConvertTriStripToTriList(_dst, _dstSize, (const uint16_t*)_indices, _numIndices); + + case TopologyConvert::TriListFlipWinding: + if (_index32) + { + return topologyConvertTriListFlipWinding(_dst, _dstSize, (const uint32_t*)_indices, _numIndices); + } + + return topologyConvertTriListFlipWinding(_dst, _dstSize, (const uint16_t*)_indices, _numIndices); + + case TopologyConvert::TriListToLineList: + if (NULL == _allocator) + { + return 0; + } + + if (_index32) + { + return topologyConvertTriListToLineList<uint32_t, uint64_t>(_dst, _dstSize, (const uint32_t*)_indices, _numIndices, _allocator); + } + + return topologyConvertTriListToLineList<uint16_t, uint32_t>(_dst, _dstSize, (const uint16_t*)_indices, _numIndices, _allocator); + + case TopologyConvert::LineStripToLineList: + if (_index32) + { + return topologyConvertLineStripToLineList(_dst, _dstSize, (const uint32_t*)_indices, _numIndices); + } + + return topologyConvertLineStripToLineList(_dst, _dstSize, (const uint16_t*)_indices, _numIndices); + + default: + break; + } + + return 0; + } + +} //namespace bgfx diff --git a/3rdparty/bgfx/src/topology.h b/3rdparty/bgfx/src/topology.h new file mode 100644 index 00000000000..014d67559df --- /dev/null +++ b/3rdparty/bgfx/src/topology.h @@ -0,0 +1,33 @@ +/* + * Copyright 2011-2016 Branimir Karadzic. All rights reserved. + * License: https://github.com/bkaradzic/bgfx#license-bsd-2-clause + */ + +#ifndef BGFX_TOPOLOGY_H_HEADER_GUARD +#define BGFX_TOPOLOGY_H_HEADER_GUARD + +#include <bgfx/bgfx.h> + +namespace bgfx +{ + /// Convert index buffer for use with different primitive topologies. + /// + /// @param[in] _conversion Conversion type, see `TopologyConvert::Enum`. + /// @param[in] _dst Destination index buffer. If this argument it NULL + /// function will return number of indices after conversion. + /// @param[in] _dstSize Destination index buffer in bytes. It must be + /// large enough to contain output indices. If destination size is + /// insufficient index buffer will be truncated. + /// @param[in] _indices Source indices. + /// @param[in] _numIndices Number of input indices. + /// @param[in] _index32 Set to `true` if input indices are 32-bit. + /// + /// @returns Number of output indices after conversion. + /// + /// @attention C99 equivalent is `bgfx_topology_convert`. + /// + uint32_t topologyConvert(TopologyConvert::Enum _conversion, void* _dst, uint32_t _dstSize, const void* _indices, uint32_t _numIndices, bool _index32, bx::AllocatorI* _allocator); + +} // namespace bgfx + +#endif // BGFX_TOPOLOGY_H_HEADER_GUARD diff --git a/3rdparty/bgfx/src/vertexdecl.cpp b/3rdparty/bgfx/src/vertexdecl.cpp index 91ef865d0c9..c5fb4b05dec 100644 --- a/3rdparty/bgfx/src/vertexdecl.cpp +++ b/3rdparty/bgfx/src/vertexdecl.cpp @@ -6,9 +6,10 @@ #include <string.h> #include <bx/debug.h> #include <bx/hash.h> -#include <bx/uint32_t.h> -#include <bx/string.h> #include <bx/readerwriter.h> +#include <bx/radixsort.h> +#include <bx/string.h> +#include <bx/uint32_t.h> #include "config.h" #include "vertexdecl.h" @@ -285,8 +286,10 @@ namespace bgfx return s_attribTypeToId[_attr].id; } - int32_t write(bx::WriterI* _writer, const VertexDecl& _decl) + int32_t write(bx::WriterI* _writer, const VertexDecl& _decl, bx::Error* _err) { + BX_ERROR_SCOPE(_err); + int32_t total = 0; uint8_t numAttrs = 0; @@ -295,8 +298,8 @@ namespace bgfx numAttrs += UINT16_MAX == _decl.m_attributes[attr] ? 0 : 1; } - total += bx::write(_writer, numAttrs); - total += bx::write(_writer, _decl.m_stride); + total += bx::write(_writer, numAttrs, _err); + total += bx::write(_writer, _decl.m_stride, _err); for (uint32_t attr = 0; attr < Attrib::Count; ++attr) { @@ -307,49 +310,61 @@ namespace bgfx bool normalized; bool asInt; _decl.decode(Attrib::Enum(attr), num, type, normalized, asInt); - total += bx::write(_writer, _decl.m_offset[attr]); - total += bx::write(_writer, s_attribToId[attr].id); - total += bx::write(_writer, num); - total += bx::write(_writer, s_attribTypeToId[type].id); - total += bx::write(_writer, normalized); - total += bx::write(_writer, asInt); + total += bx::write(_writer, _decl.m_offset[attr], _err); + total += bx::write(_writer, s_attribToId[attr].id, _err); + total += bx::write(_writer, num, _err); + total += bx::write(_writer, s_attribTypeToId[type].id, _err); + total += bx::write(_writer, normalized, _err); + total += bx::write(_writer, asInt, _err); } } return total; } - int32_t read(bx::ReaderI* _reader, VertexDecl& _decl) + int32_t read(bx::ReaderI* _reader, VertexDecl& _decl, bx::Error* _err) { + BX_ERROR_SCOPE(_err); + int32_t total = 0; uint8_t numAttrs; - total += bx::read(_reader, numAttrs); + total += bx::read(_reader, numAttrs, _err); uint16_t stride; - total += bx::read(_reader, stride); + total += bx::read(_reader, stride, _err); + + if (!_err->isOk() ) + { + return total; + } _decl.begin(); for (uint32_t ii = 0; ii < numAttrs; ++ii) { uint16_t offset; - total += bx::read(_reader, offset); + total += bx::read(_reader, offset, _err); uint16_t attribId = 0; - total += bx::read(_reader, attribId); + total += bx::read(_reader, attribId, _err); uint8_t num; - total += bx::read(_reader, num); + total += bx::read(_reader, num, _err); uint16_t attribTypeId; - total += bx::read(_reader, attribTypeId); + total += bx::read(_reader, attribTypeId, _err); bool normalized; - total += bx::read(_reader, normalized); + total += bx::read(_reader, normalized, _err); bool asInt; - total += bx::read(_reader, asInt); + total += bx::read(_reader, asInt, _err); + + if (!_err->isOk() ) + { + return total; + } Attrib::Enum attr = idToAttrib(attribId); AttribType::Enum type = idToAttribType(attribTypeId); @@ -839,4 +854,5 @@ namespace bgfx return (uint16_t)numVertices; } + } // namespace bgfx diff --git a/3rdparty/bgfx/src/vertexdecl.h b/3rdparty/bgfx/src/vertexdecl.h index 642aae35592..866c53a3f22 100644 --- a/3rdparty/bgfx/src/vertexdecl.h +++ b/3rdparty/bgfx/src/vertexdecl.h @@ -30,10 +30,10 @@ namespace bgfx AttribType::Enum idToAttribType(uint16_t id); /// - int32_t write(bx::WriterI* _writer, const bgfx::VertexDecl& _decl); + int32_t write(bx::WriterI* _writer, const bgfx::VertexDecl& _decl, bx::Error* _err = NULL); /// - int32_t read(bx::ReaderI* _reader, bgfx::VertexDecl& _decl); + int32_t read(bx::ReaderI* _reader, bgfx::VertexDecl& _decl, bx::Error* _err = NULL); } // namespace bgfx |