From 7bc62b1d074ac58fcbc74d27329f11bf402a2f3a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Branimir=20Karad=C5=BEi=C4=87?= Date: Sat, 26 Apr 2014 23:48:41 -0700 Subject: [PATCH] Added tristrip support. --- include/bgfx.h | 15 +++- src/bgfx.cpp | 18 +++- src/bgfx_p.h | 16 ++-- src/renderer_d3d11.cpp | 163 ++++++++++++++++++++++++---------- src/renderer_d3d9.cpp | 182 ++++++++++++++++++++++++++------------ src/renderer_gl.cpp | 88 +++++++++++------- tools/shaderc/shaderc.cpp | 26 +++--- 7 files changed, 351 insertions(+), 157 deletions(-) diff --git a/include/bgfx.h b/include/bgfx.h index 9d577229..938fc62b 100644 --- a/include/bgfx.h +++ b/include/bgfx.h @@ -58,8 +58,9 @@ #define BGFX_STATE_ALPHA_REF_SHIFT 40 #define BGFX_STATE_ALPHA_REF_MASK UINT64_C(0x0000ff0000000000) -#define BGFX_STATE_PT_LINES UINT64_C(0x0001000000000000) -#define BGFX_STATE_PT_POINTS UINT64_C(0x0002000000000000) +#define BGFX_STATE_PT_TRISTRIP UINT64_C(0x0001000000000000) +#define BGFX_STATE_PT_LINES UINT64_C(0x0002000000000000) +#define BGFX_STATE_PT_POINTS UINT64_C(0x0003000000000000) #define BGFX_STATE_PT_SHIFT 48 #define BGFX_STATE_PT_MASK UINT64_C(0x0003000000000000) @@ -1257,7 +1258,10 @@ namespace bgfx void setIndexBuffer(DynamicIndexBufferHandle _handle, uint32_t _firstIndex = 0, uint32_t _numIndices = UINT32_MAX); /// Set index buffer for draw primitive. - void setIndexBuffer(const TransientIndexBuffer* _tib, uint32_t _numIndices = UINT32_MAX); + void setIndexBuffer(const TransientIndexBuffer* _tib); + + /// Set index buffer for draw primitive. + void setIndexBuffer(const TransientIndexBuffer* _tib, uint32_t _firstIndex, uint32_t _numIndices); /// Set vertex buffer for draw primitive. void setVertexBuffer(VertexBufferHandle _handle); @@ -1269,7 +1273,10 @@ namespace bgfx void setVertexBuffer(DynamicVertexBufferHandle _handle, uint32_t _numVertices = UINT32_MAX); /// Set vertex buffer for draw primitive. - void setVertexBuffer(const TransientVertexBuffer* _tvb, uint32_t _numVertices = UINT32_MAX); + void setVertexBuffer(const TransientVertexBuffer* _tvb); + + /// Set vertex buffer for draw primitive. + void setVertexBuffer(const TransientVertexBuffer* _tvb, uint32_t _startVertex, uint32_t _numVertices); /// Set instance data buffer for draw primitive. void setInstanceDataBuffer(const InstanceDataBuffer* _idb, uint16_t _num = UINT16_MAX); diff --git a/src/bgfx.cpp b/src/bgfx.cpp index ee53c412..5016a585 100644 --- a/src/bgfx.cpp +++ b/src/bgfx.cpp @@ -2334,12 +2334,17 @@ namespace bgfx s_ctx->setIndexBuffer(_handle, _firstIndex, _numIndices); } - void setIndexBuffer(const TransientIndexBuffer* _tib, uint32_t _numIndices) + void setIndexBuffer(const TransientIndexBuffer* _tib) + { + setIndexBuffer(_tib, 0, UINT32_MAX); + } + + void setIndexBuffer(const TransientIndexBuffer* _tib, uint32_t _firstIndex, uint32_t _numIndices) { BGFX_CHECK_MAIN_THREAD(); BX_CHECK(NULL != _tib, "_tib can't be NULL"); uint32_t numIndices = bx::uint32_min(_numIndices, _tib->size/2); - s_ctx->setIndexBuffer(_tib, numIndices); + s_ctx->setIndexBuffer(_tib, _tib->startIndex + _firstIndex, numIndices); } void setVertexBuffer(VertexBufferHandle _handle) @@ -2359,11 +2364,16 @@ namespace bgfx s_ctx->setVertexBuffer(_handle, _numVertices); } - void setVertexBuffer(const TransientVertexBuffer* _tvb, uint32_t _numVertices) + void setVertexBuffer(const TransientVertexBuffer* _tvb) + { + setVertexBuffer(_tvb, 0, UINT32_MAX); + } + + void setVertexBuffer(const TransientVertexBuffer* _tvb, uint32_t _startVertex, uint32_t _numVertices) { BGFX_CHECK_MAIN_THREAD(); BX_CHECK(NULL != _tvb, "_tvb can't be NULL"); - s_ctx->setVertexBuffer(_tvb, _numVertices); + s_ctx->setVertexBuffer(_tvb, _tvb->startVertex + _startVertex, _numVertices); } void setInstanceDataBuffer(const InstanceDataBuffer* _idb, uint16_t _num) diff --git a/src/bgfx_p.h b/src/bgfx_p.h index 66643839..3fcaa58a 100644 --- a/src/bgfx_p.h +++ b/src/bgfx_p.h @@ -1146,10 +1146,10 @@ namespace bgfx m_state.m_indexBuffer = _handle; } - void setIndexBuffer(const TransientIndexBuffer* _tib, uint32_t _numIndices) + void setIndexBuffer(const TransientIndexBuffer* _tib, uint32_t _firstIndex, uint32_t _numIndices) { m_state.m_indexBuffer = _tib->handle; - m_state.m_startIndex = _tib->startIndex; + m_state.m_startIndex = _firstIndex; m_state.m_numIndices = _numIndices; m_discard = 0 == _numIndices; } @@ -1170,9 +1170,9 @@ namespace bgfx m_state.m_vertexDecl = _dvb.m_decl; } - void setVertexBuffer(const TransientVertexBuffer* _tvb, uint32_t _numVertices) + void setVertexBuffer(const TransientVertexBuffer* _tvb, uint32_t _startVertex, uint32_t _numVertices) { - m_state.m_startVertex = _tvb->startVertex; + m_state.m_startVertex = _startVertex; m_state.m_numVertices = bx::uint32_min(_tvb->size/_tvb->stride, _numVertices); m_state.m_vertexBuffer = _tvb->handle; m_state.m_vertexDecl = _tvb->decl; @@ -2589,9 +2589,9 @@ namespace bgfx m_submit->setIndexBuffer(m_dynamicIndexBuffers[_handle.idx].m_handle, _firstIndex, _numIndices); } - BGFX_API_FUNC(void setIndexBuffer(const TransientIndexBuffer* _tib, uint32_t _numIndices) ) + BGFX_API_FUNC(void setIndexBuffer(const TransientIndexBuffer* _tib, uint32_t _firstIndex, uint32_t _numIndices) ) { - m_submit->setIndexBuffer(_tib, _numIndices); + m_submit->setIndexBuffer(_tib, _firstIndex, _numIndices); } BGFX_API_FUNC(void setVertexBuffer(VertexBufferHandle _handle, uint32_t _numVertices, uint32_t _startVertex) ) @@ -2604,9 +2604,9 @@ namespace bgfx m_submit->setVertexBuffer(m_dynamicVertexBuffers[_handle.idx], _numVertices); } - BGFX_API_FUNC(void setVertexBuffer(const TransientVertexBuffer* _tvb, uint32_t _numVertices) ) + BGFX_API_FUNC(void setVertexBuffer(const TransientVertexBuffer* _tvb, uint32_t _startVertex, uint32_t _numVertices) ) { - m_submit->setVertexBuffer(_tvb, _numVertices); + m_submit->setVertexBuffer(_tvb, _startVertex, _numVertices); } BGFX_API_FUNC(void setInstanceDataBuffer(const InstanceDataBuffer* _idb, uint16_t _num) ) diff --git a/src/renderer_d3d11.cpp b/src/renderer_d3d11.cpp index 6f6b218f..73b347e5 100644 --- a/src/renderer_d3d11.cpp +++ b/src/renderer_d3d11.cpp @@ -12,11 +12,28 @@ namespace bgfx { static wchar_t s_viewNameW[BGFX_CONFIG_MAX_VIEWS][256]; - static const D3D11_PRIMITIVE_TOPOLOGY s_primType[] = + struct PrimInfo { - D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST, - D3D11_PRIMITIVE_TOPOLOGY_LINELIST, - D3D11_PRIMITIVE_TOPOLOGY_POINTLIST, + D3D11_PRIMITIVE_TOPOLOGY m_type; + uint32_t m_min; + uint32_t m_div; + uint32_t m_sub; + }; + + static const PrimInfo s_primInfo[] = + { + { D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST, 3, 3, 0 }, + { D3D11_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP, 3, 1, 2 }, + { D3D11_PRIMITIVE_TOPOLOGY_LINELIST, 2, 2, 0 }, + { D3D11_PRIMITIVE_TOPOLOGY_POINTLIST, 1, 1, 0 }, + }; + + static const char* s_primName[] = + { + "TriList", + "TriStrip", + "Line", + "Point", }; static const uint32_t s_checkMsaa[] = @@ -498,6 +515,31 @@ namespace bgfx ); BGFX_FATAL(SUCCEEDED(hr), Fatal::UnableToInitialize, "Failed to create swap chain."); + if (BX_ENABLED(BGFX_CONFIG_DEBUG) ) + { + ID3D11InfoQueue* infoQueue; + hr = m_device->QueryInterface(__uuidof(ID3D11InfoQueue), (void**)&infoQueue); + BGFX_FATAL(SUCCEEDED(hr), Fatal::UnableToInitialize, "Unable to create Direct3D11 device."); + + infoQueue->SetBreakOnSeverity(D3D11_MESSAGE_SEVERITY_CORRUPTION, true); + infoQueue->SetBreakOnSeverity(D3D11_MESSAGE_SEVERITY_ERROR, true); + infoQueue->SetBreakOnSeverity(D3D11_MESSAGE_SEVERITY_WARNING, false); + + D3D11_INFO_QUEUE_FILTER filter; + memset(&filter, 0, sizeof(filter) ); + + D3D11_MESSAGE_CATEGORY categies[] = + { + D3D11_MESSAGE_CATEGORY_STATE_SETTING, + D3D11_MESSAGE_CATEGORY_EXECUTION, + }; + filter.DenyList.NumCategories = BX_COUNTOF(categies); + filter.DenyList.pCategoryList = categies; + infoQueue->PushStorageFilter(&filter); + + DX_RELEASE(infoQueue, 3); + } + UniformHandle handle = BGFX_INVALID_HANDLE; for (uint32_t ii = 0; ii < PredefinedUniform::Count; ++ii) { @@ -1423,7 +1465,7 @@ namespace bgfx data = (const char*)s_renderCtx->m_uniforms[handle.idx]; } -#define CASE_IMPLEMENT_UNIFORM(_uniform, _glsuffix, _dxsuffix, _type) \ +#define CASE_IMPLEMENT_UNIFORM(_uniform, _dxsuffix, _type) \ case UniformType::_uniform: \ case UniformType::_uniform|BGFX_UNIFORM_FRAGMENTBIT: \ { \ @@ -1431,17 +1473,40 @@ namespace bgfx } \ break; - switch ((int32_t)type) + switch ( (int32_t)type) { - CASE_IMPLEMENT_UNIFORM(Uniform1i, 1iv, I, int); - CASE_IMPLEMENT_UNIFORM(Uniform1f, 1fv, F, float); - CASE_IMPLEMENT_UNIFORM(Uniform1iv, 1iv, I, int); - CASE_IMPLEMENT_UNIFORM(Uniform1fv, 1fv, F, float); - CASE_IMPLEMENT_UNIFORM(Uniform2fv, 2fv, F, float); - CASE_IMPLEMENT_UNIFORM(Uniform3fv, 3fv, F, float); - CASE_IMPLEMENT_UNIFORM(Uniform4fv, 4fv, F, float); - CASE_IMPLEMENT_UNIFORM(Uniform3x3fv, Matrix3fv, F, float); - CASE_IMPLEMENT_UNIFORM(Uniform4x4fv, Matrix4fv, F, float); + case UniformType::Uniform3x3fv: + case UniformType::Uniform3x3fv|BGFX_UNIFORM_FRAGMENTBIT: \ + { + float* value = (float*)data; + for (uint32_t ii = 0, count = num/3; ii < count; ++ii, loc += 3*16, value += 9) + { + Matrix4 mtx; + mtx.un.val[ 0] = value[0]; + mtx.un.val[ 1] = value[1]; + mtx.un.val[ 2] = value[2]; + mtx.un.val[ 3] = 0.0f; + mtx.un.val[ 4] = value[3]; + mtx.un.val[ 5] = value[4]; + mtx.un.val[ 6] = value[5]; + mtx.un.val[ 7] = 0.0f; + mtx.un.val[ 8] = value[6]; + mtx.un.val[ 9] = value[7]; + mtx.un.val[10] = value[8]; + mtx.un.val[11] = 0.0f; + s_renderCtx->setShaderConstant(type, loc, &mtx.un.val[0], 3); + } + } + break; + + CASE_IMPLEMENT_UNIFORM(Uniform1i, I, int); + CASE_IMPLEMENT_UNIFORM(Uniform1f, F, float); + CASE_IMPLEMENT_UNIFORM(Uniform1iv, I, int); + CASE_IMPLEMENT_UNIFORM(Uniform1fv, F, float); + CASE_IMPLEMENT_UNIFORM(Uniform2fv, F, float); + CASE_IMPLEMENT_UNIFORM(Uniform3fv, F, float); + CASE_IMPLEMENT_UNIFORM(Uniform4fv, F, float); + CASE_IMPLEMENT_UNIFORM(Uniform4x4fv, F, float); case UniformType::End: break; @@ -2340,17 +2405,20 @@ namespace bgfx uint8_t view = 0xff; FrameBufferHandle fbh = BGFX_INVALID_HANDLE; float alphaRef = 0.0f; - D3D11_PRIMITIVE_TOPOLOGY primType = D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST; - deviceCtx->IASetPrimitiveTopology(primType); - uint32_t primNumVerts = 3; + + const uint64_t pt = m_render->m_debug&BGFX_DEBUG_WIREFRAME ? BGFX_STATE_PT_LINES : 0; + uint8_t primIndex = uint8_t(pt>>BGFX_STATE_PT_SHIFT); + PrimInfo prim = s_primInfo[primIndex]; + deviceCtx->IASetPrimitiveTopology(prim.m_type); + bool viewHasScissor = false; Rect viewScissorRect; viewScissorRect.clear(); - uint32_t statsNumPrimsSubmitted = 0; + uint32_t statsNumPrimsSubmitted[BX_COUNTOF(s_primInfo)] = {}; + uint32_t statsNumPrimsRendered[BX_COUNTOF(s_primInfo)] = {}; + uint32_t statsNumInstances[BX_COUNTOF(s_primInfo)] = {}; uint32_t statsNumIndices = 0; - uint32_t statsNumInstances = 0; - uint32_t statsNumPrimsRendered = 0; if (0 == (m_render->m_debug&BGFX_DEBUG_IFH) ) { @@ -2411,12 +2479,12 @@ namespace bgfx s_renderCtx->setBlendState(newFlags); s_renderCtx->setDepthStencilState(newFlags, packStencil(BGFX_STENCIL_DEFAULT, BGFX_STENCIL_DEFAULT) ); - uint8_t primIndex = uint8_t( (newFlags&BGFX_STATE_PT_MASK)>>BGFX_STATE_PT_SHIFT); - if (primType != s_primType[primIndex]) + const uint64_t pt = newFlags&BGFX_STATE_PT_MASK; + primIndex = uint8_t(pt>>BGFX_STATE_PT_SHIFT); + if (prim.m_type != s_primInfo[primIndex].m_type) { - primType = s_primType[primIndex]; - primNumVerts = 3-primIndex; - deviceCtx->IASetPrimitiveTopology(primType); + prim = s_primInfo[primIndex]; + deviceCtx->IASetPrimitiveTopology(prim.m_type); } } @@ -2488,12 +2556,12 @@ namespace bgfx alphaRef = ref/255.0f; } - uint8_t primIndex = uint8_t( (newFlags&BGFX_STATE_PT_MASK)>>BGFX_STATE_PT_SHIFT); - if (primType != s_primType[primIndex]) + const uint64_t pt = newFlags&BGFX_STATE_PT_MASK; + primIndex = uint8_t(pt>>BGFX_STATE_PT_SHIFT); + if (prim.m_type != s_primInfo[primIndex].m_type) { - primType = s_primType[primIndex]; - primNumVerts = 3-primIndex; - deviceCtx->IASetPrimitiveTopology(primType); + prim = s_primInfo[primIndex]; + deviceCtx->IASetPrimitiveTopology(prim.m_type); } } @@ -2768,7 +2836,7 @@ namespace bgfx if (UINT32_MAX == state.m_numIndices) { numIndices = s_renderCtx->m_indexBuffers[state.m_indexBuffer.idx].m_size/2; - numPrimsSubmitted = numIndices/primNumVerts; + numPrimsSubmitted = numIndices/prim.m_div - prim.m_sub; numInstances = state.m_numInstances; numPrimsRendered = numPrimsSubmitted*state.m_numInstances; @@ -2779,10 +2847,10 @@ namespace bgfx , 0 ); } - else if (primNumVerts <= state.m_numIndices) + else if (prim.m_min <= state.m_numIndices) { numIndices = state.m_numIndices; - numPrimsSubmitted = numIndices/primNumVerts; + numPrimsSubmitted = numIndices/prim.m_div - prim.m_sub; numInstances = state.m_numInstances; numPrimsRendered = numPrimsSubmitted*state.m_numInstances; @@ -2796,7 +2864,7 @@ namespace bgfx } else { - numPrimsSubmitted = numVertices/primNumVerts; + numPrimsSubmitted = numVertices/prim.m_div - prim.m_sub; numInstances = state.m_numInstances; numPrimsRendered = numPrimsSubmitted*state.m_numInstances; @@ -2807,10 +2875,10 @@ namespace bgfx ); } - statsNumPrimsSubmitted += numPrimsSubmitted; + statsNumPrimsSubmitted[primIndex] += numPrimsSubmitted; + statsNumPrimsRendered[primIndex] += numPrimsRendered; + statsNumInstances[primIndex] += numInstances; statsNumIndices += numIndices; - statsNumInstances += numInstances; - statsNumPrimsRendered += numPrimsRendered; } } @@ -2882,18 +2950,23 @@ namespace bgfx , m_render->m_num , elapsedCpuMs ); - tvm.printf(10, pos++, 0x8e, " Prims: %7d (#inst: %5d), submitted: %7d" - , statsNumPrimsRendered - , statsNumInstances - , statsNumPrimsSubmitted - ); + for (uint32_t ii = 0; ii < BX_COUNTOF(s_primInfo); ++ii) + { + tvm.printf(10, pos++, 0x8e, " %8s: %7d (#inst: %5d), submitted: %7d" + , s_primName[ii] + , statsNumPrimsRendered[ii] + , statsNumInstances[ii] + , statsNumPrimsSubmitted[ii] + ); + } - double captureMs = double(captureElapsed)*toMs; - tvm.printf(10, pos++, 0x8e, " Capture: %3.4f [ms]", captureMs); tvm.printf(10, pos++, 0x8e, " Indices: %7d", statsNumIndices); tvm.printf(10, pos++, 0x8e, " DVB size: %7d", m_render->m_vboffset); tvm.printf(10, pos++, 0x8e, " DIB size: %7d", m_render->m_iboffset); + double captureMs = double(captureElapsed)*toMs; + tvm.printf(10, pos++, 0x8e, " Capture: %3.4f [ms]", captureMs); + uint8_t attr[2] = { 0x89, 0x8a }; uint8_t attrIndex = m_render->m_waitSubmit < m_render->m_waitRender; diff --git a/src/renderer_d3d9.cpp b/src/renderer_d3d9.cpp index 902f4557..e19a23d0 100644 --- a/src/renderer_d3d9.cpp +++ b/src/renderer_d3d9.cpp @@ -12,11 +12,28 @@ namespace bgfx { static wchar_t s_viewNameW[BGFX_CONFIG_MAX_VIEWS][256]; - static const D3DPRIMITIVETYPE s_primType[] = + struct PrimInfo { - D3DPT_TRIANGLELIST, - D3DPT_LINELIST, - D3DPT_POINTLIST, + D3DPRIMITIVETYPE m_type; + uint32_t m_min; + uint32_t m_div; + uint32_t m_sub; + }; + + static const PrimInfo s_primInfo[] = + { + { D3DPT_TRIANGLELIST, 3, 3, 0 }, + { D3DPT_TRIANGLESTRIP, 3, 1, 2 }, + { D3DPT_LINELIST, 2, 2, 0 }, + { D3DPT_POINTLIST, 1, 1, 0 }, + }; + + static const char* s_primName[] = + { + "TriList", + "TriStrip", + "Line", + "Point", }; static const D3DMULTISAMPLE_TYPE s_checkMsaa[] = @@ -2047,6 +2064,8 @@ namespace bgfx { reset(); + IDirect3DDevice9* device = s_renderCtx->m_device; + do { uint32_t opcode = read(); @@ -2074,32 +2093,77 @@ namespace bgfx data = (const char*)s_renderCtx->m_uniforms[handle.idx]; } -#define CASE_IMPLEMENT_UNIFORM(_uniform, _glsuffix, _dxsuffix, _type) \ - case UniformType::_uniform: \ - { \ - _type* value = (_type*)data; \ - s_renderCtx->m_device->SetVertexShaderConstant##_dxsuffix(loc, value, num); \ - } \ - break; \ - \ - case UniformType::_uniform|BGFX_UNIFORM_FRAGMENTBIT: \ - { \ - _type* value = (_type*)data; \ - s_renderCtx->m_device->SetPixelShaderConstant##_dxsuffix(loc, value, num); \ - } \ - break +#define CASE_IMPLEMENT_UNIFORM(_uniform, _dxsuffix, _type) \ + case UniformType::_uniform: \ + { \ + _type* value = (_type*)data; \ + DX_CHECK(device->SetVertexShaderConstant##_dxsuffix(loc, value, num) ); \ + } \ + break; \ + \ + case UniformType::_uniform|BGFX_UNIFORM_FRAGMENTBIT: \ + { \ + _type* value = (_type*)data; \ + DX_CHECK(device->SetPixelShaderConstant##_dxsuffix(loc, value, num) ); \ + } \ + break - switch ((int32_t)type) + switch ( (int32_t)type) { - CASE_IMPLEMENT_UNIFORM(Uniform1i, 1iv, I, int); - CASE_IMPLEMENT_UNIFORM(Uniform1f, 1fv, F, float); - CASE_IMPLEMENT_UNIFORM(Uniform1iv, 1iv, I, int); - CASE_IMPLEMENT_UNIFORM(Uniform1fv, 1fv, F, float); - CASE_IMPLEMENT_UNIFORM(Uniform2fv, 2fv, F, float); - CASE_IMPLEMENT_UNIFORM(Uniform3fv, 3fv, F, float); - CASE_IMPLEMENT_UNIFORM(Uniform4fv, 4fv, F, float); - CASE_IMPLEMENT_UNIFORM(Uniform3x3fv, Matrix3fv, F, float); - CASE_IMPLEMENT_UNIFORM(Uniform4x4fv, Matrix4fv, F, float); + case UniformType::Uniform3x3fv: + { + float* value = (float*)data; + for (uint32_t ii = 0, count = num/3; ii < count; ++ii, loc += 3, value += 9) + { + Matrix4 mtx; + mtx.un.val[ 0] = value[0]; + mtx.un.val[ 1] = value[1]; + mtx.un.val[ 2] = value[2]; + mtx.un.val[ 3] = 0.0f; + mtx.un.val[ 4] = value[3]; + mtx.un.val[ 5] = value[4]; + mtx.un.val[ 6] = value[5]; + mtx.un.val[ 7] = 0.0f; + mtx.un.val[ 8] = value[6]; + mtx.un.val[ 9] = value[7]; + mtx.un.val[10] = value[8]; + mtx.un.val[11] = 0.0f; + DX_CHECK(device->SetVertexShaderConstantF(loc, &mtx.un.val[0], 3) ); + } + } + break; + + case UniformType::Uniform3x3fv|BGFX_UNIFORM_FRAGMENTBIT: + { + float* value = (float*)data; + for (uint32_t ii = 0, count = num/3; ii < count; ++ii, loc += 3, value += 9) + { + Matrix4 mtx; + mtx.un.val[ 0] = value[0]; + mtx.un.val[ 1] = value[1]; + mtx.un.val[ 2] = value[2]; + mtx.un.val[ 3] = 0.0f; + mtx.un.val[ 4] = value[3]; + mtx.un.val[ 5] = value[4]; + mtx.un.val[ 6] = value[5]; + mtx.un.val[ 7] = 0.0f; + mtx.un.val[ 8] = value[6]; + mtx.un.val[ 9] = value[7]; + mtx.un.val[10] = value[8]; + mtx.un.val[11] = 0.0f; + DX_CHECK(device->SetPixelShaderConstantF(loc, &mtx.un.val[0], 3) ); + } + } + break; + + CASE_IMPLEMENT_UNIFORM(Uniform1i, I, int); + CASE_IMPLEMENT_UNIFORM(Uniform1f, F, float); + CASE_IMPLEMENT_UNIFORM(Uniform1iv, I, int); + CASE_IMPLEMENT_UNIFORM(Uniform1fv, F, float); + CASE_IMPLEMENT_UNIFORM(Uniform2fv, F, float); + CASE_IMPLEMENT_UNIFORM(Uniform3fv, F, float); + CASE_IMPLEMENT_UNIFORM(Uniform4fv, F, float); + CASE_IMPLEMENT_UNIFORM(Uniform4x4fv, F, float); case UniformType::End: break; @@ -2142,8 +2206,8 @@ namespace bgfx DX_CHECK(device->SetRenderState(D3DRS_FILLMODE, D3DFILL_SOLID) ); Program& program = s_renderCtx->m_program[m_program.idx]; - device->SetVertexShader( (IDirect3DVertexShader9*)program.m_vsh->m_ptr); - device->SetPixelShader( (IDirect3DPixelShader9*)program.m_fsh->m_ptr); + DX_CHECK(device->SetVertexShader( (IDirect3DVertexShader9*)program.m_vsh->m_ptr) ); + DX_CHECK(device->SetPixelShader( (IDirect3DPixelShader9*)program.m_fsh->m_ptr) ); VertexBuffer& vb = s_renderCtx->m_vertexBuffers[m_vb->handle.idx]; VertexDeclaration& vertexDecl = s_renderCtx->m_vertexDecls[m_vb->decl.idx]; @@ -2407,16 +2471,19 @@ namespace bgfx FrameBufferHandle fbh = BGFX_INVALID_HANDLE; float alphaRef = 0.0f; uint32_t blendFactor = 0; - D3DPRIMITIVETYPE primType = D3DPT_TRIANGLELIST; - uint32_t primNumVerts = 3; + + const uint64_t pt = m_render->m_debug&BGFX_DEBUG_WIREFRAME ? BGFX_STATE_PT_LINES : 0; + uint8_t primIndex = uint8_t(pt>>BGFX_STATE_PT_SHIFT); + PrimInfo prim = s_primInfo[primIndex]; + bool viewHasScissor = false; Rect viewScissorRect; viewScissorRect.clear(); - uint32_t statsNumPrimsSubmitted = 0; + uint32_t statsNumPrimsSubmitted[BX_COUNTOF(s_primInfo)] = {}; + uint32_t statsNumPrimsRendered[BX_COUNTOF(s_primInfo)] = {}; + uint32_t statsNumInstances[BX_COUNTOF(s_primInfo)] = {}; uint32_t statsNumIndices = 0; - uint32_t statsNumInstances = 0; - uint32_t statsNumPrimsRendered = 0; s_renderCtx->invalidateSamplerState(); @@ -2713,9 +2780,9 @@ namespace bgfx blendFactor = state.m_rgba; } - uint8_t primIndex = uint8_t( (newFlags&BGFX_STATE_PT_MASK)>>BGFX_STATE_PT_SHIFT); - primType = s_primType[primIndex]; - primNumVerts = 3-primIndex; + const uint64_t pt = m_render->m_debug&BGFX_DEBUG_WIREFRAME ? BGFX_STATE_PT_LINES : newFlags&BGFX_STATE_PT_MASK; + primIndex = uint8_t(pt>>BGFX_STATE_PT_SHIFT); + prim = s_primInfo[primIndex]; } bool programChanged = false; @@ -2963,11 +3030,11 @@ namespace bgfx if (UINT32_MAX == state.m_numIndices) { numIndices = s_renderCtx->m_indexBuffers[state.m_indexBuffer.idx].m_size/2; - numPrimsSubmitted = numIndices/primNumVerts; + numPrimsSubmitted = numIndices/prim.m_div - prim.m_sub; numInstances = state.m_numInstances; numPrimsRendered = numPrimsSubmitted*state.m_numInstances; - DX_CHECK(device->DrawIndexedPrimitive(primType + DX_CHECK(device->DrawIndexedPrimitive(prim.m_type , state.m_startVertex , 0 , numVertices @@ -2975,14 +3042,14 @@ namespace bgfx , numPrimsSubmitted ) ); } - else if (primNumVerts <= state.m_numIndices) + else if (prim.m_min <= state.m_numIndices) { numIndices = state.m_numIndices; - numPrimsSubmitted = numIndices/primNumVerts; + numPrimsSubmitted = numIndices/prim.m_div - prim.m_sub; numInstances = state.m_numInstances; numPrimsRendered = numPrimsSubmitted*state.m_numInstances; - DX_CHECK(device->DrawIndexedPrimitive(primType + DX_CHECK(device->DrawIndexedPrimitive(prim.m_type , state.m_startVertex , 0 , numVertices @@ -2993,20 +3060,20 @@ namespace bgfx } else { - numPrimsSubmitted = numVertices/primNumVerts; + numPrimsSubmitted = numVertices/prim.m_div - prim.m_sub; numInstances = state.m_numInstances; numPrimsRendered = numPrimsSubmitted*state.m_numInstances; - DX_CHECK(device->DrawPrimitive(primType + DX_CHECK(device->DrawPrimitive(prim.m_type , state.m_startVertex , numPrimsSubmitted ) ); } - statsNumPrimsSubmitted += numPrimsSubmitted; + statsNumPrimsSubmitted[primIndex] += numPrimsSubmitted; + statsNumPrimsRendered[primIndex] += numPrimsRendered; + statsNumInstances[primIndex] += numInstances; statsNumIndices += numIndices; - statsNumInstances += numInstances; - statsNumPrimsRendered += numPrimsRendered; } } @@ -3074,18 +3141,23 @@ namespace bgfx , m_render->m_num , elapsedCpuMs ); - tvm.printf(10, pos++, 0x8e, " Prims: %7d (#inst: %5d), submitted: %7d" - , statsNumPrimsRendered - , statsNumInstances - , statsNumPrimsSubmitted - ); + for (uint32_t ii = 0; ii < BX_COUNTOF(s_primInfo); ++ii) + { + tvm.printf(10, pos++, 0x8e, " %8s: %7d (#inst: %5d), submitted: %7d" + , s_primName[ii] + , statsNumPrimsRendered[ii] + , statsNumInstances[ii] + , statsNumPrimsSubmitted[ii] + ); + } - double captureMs = double(captureElapsed)*toMs; - tvm.printf(10, pos++, 0x8e, " Capture: %3.4f [ms]", captureMs); tvm.printf(10, pos++, 0x8e, " Indices: %7d", statsNumIndices); tvm.printf(10, pos++, 0x8e, " DVB size: %7d", m_render->m_vboffset); tvm.printf(10, pos++, 0x8e, " DIB size: %7d", m_render->m_iboffset); + double captureMs = double(captureElapsed)*toMs; + tvm.printf(10, pos++, 0x8e, " Capture: %3.4f [ms]", captureMs); + uint8_t attr[2] = { 0x89, 0x8a }; uint8_t attrIndex = m_render->m_waitSubmit < m_render->m_waitRender; diff --git a/src/renderer_gl.cpp b/src/renderer_gl.cpp index c32018b8..f7ea00b8 100644 --- a/src/renderer_gl.cpp +++ b/src/renderer_gl.cpp @@ -14,11 +14,28 @@ namespace bgfx { static char s_viewName[BGFX_CONFIG_MAX_VIEWS][256]; - static const GLenum s_primType[] = + struct PrimInfo { - GL_TRIANGLES, - GL_LINES, - GL_POINTS, + GLenum m_type; + uint32_t m_min; + uint32_t m_div; + uint32_t m_sub; + }; + + static const PrimInfo s_primInfo[] = + { + { GL_TRIANGLES, 3, 3, 0 }, + { GL_TRIANGLE_STRIP, 3, 1, 2 }, + { GL_LINES, 2, 2, 0 }, + { GL_POINTS, 1, 1, 0 }, + }; + + static const char* s_primName[] = + { + "TriList", + "TriStrip", + "Line", + "Point", }; static const char* s_attribName[Attrib::Count] = @@ -1660,6 +1677,9 @@ namespace bgfx { switch (_type) { + case GL_INT: + return UniformType::Uniform1iv; + case GL_FLOAT: return UniformType::Uniform1fv; @@ -1698,6 +1718,7 @@ namespace bgfx return UniformType::Uniform1iv; }; + BX_CHECK(false, "Unrecognized GL type 0x%04x.", _type); return UniformType::End; } @@ -3570,8 +3591,11 @@ namespace bgfx int32_t height = m_render->m_resolution.m_height; float alphaRef = 0.0f; uint32_t blendFactor = 0; - GLenum primType = m_render->m_debug&BGFX_DEBUG_WIREFRAME ? GL_LINES : GL_TRIANGLES; - uint32_t primNumVerts = 3; + + const uint64_t pt = m_render->m_debug&BGFX_DEBUG_WIREFRAME ? BGFX_STATE_PT_LINES : 0; + uint8_t primIndex = uint8_t(pt>>BGFX_STATE_PT_SHIFT); + PrimInfo prim = s_primInfo[primIndex]; + uint32_t baseVertex = 0; GLuint currentVao = 0; bool viewHasScissor = false; @@ -3580,10 +3604,10 @@ namespace bgfx const bool blendIndependentSupported = s_extension[Extension::ARB_draw_buffers_blend].m_supported; - uint32_t statsNumPrimsSubmitted = 0; + uint32_t statsNumPrimsSubmitted[BX_COUNTOF(s_primInfo)] = {}; + uint32_t statsNumPrimsRendered[BX_COUNTOF(s_primInfo)] = {}; + uint32_t statsNumInstances[BX_COUNTOF(s_primInfo)] = {}; uint32_t statsNumIndices = 0; - uint32_t statsNumInstances = 0; - uint32_t statsNumPrimsRendered = 0; if (0 == (m_render->m_debug&BGFX_DEBUG_IFH) ) { @@ -3901,9 +3925,9 @@ namespace bgfx blendFactor = state.m_rgba; } - uint8_t primIndex = uint8_t( (newFlags&BGFX_STATE_PT_MASK)>>BGFX_STATE_PT_SHIFT); - primType = m_render->m_debug&BGFX_DEBUG_WIREFRAME ? GL_LINES : s_primType[primIndex]; - primNumVerts = 3-primIndex; + const uint64_t pt = m_render->m_debug&BGFX_DEBUG_WIREFRAME ? BGFX_STATE_PT_LINES : newFlags&BGFX_STATE_PT_MASK; + primIndex = uint8_t(pt>>BGFX_STATE_PT_SHIFT); + prim = s_primInfo[primIndex]; } bool programChanged = false; @@ -4259,25 +4283,25 @@ namespace bgfx if (UINT32_MAX == state.m_numIndices) { numIndices = s_renderCtx->m_indexBuffers[state.m_indexBuffer.idx].m_size/2; - numPrimsSubmitted = numIndices/primNumVerts; + numPrimsSubmitted = numIndices/prim.m_div - prim.m_sub; numInstances = state.m_numInstances; numPrimsRendered = numPrimsSubmitted*state.m_numInstances; - GL_CHECK(glDrawElementsInstanced(primType + GL_CHECK(glDrawElementsInstanced(prim.m_type , numIndices , GL_UNSIGNED_SHORT , (void*)0 , state.m_numInstances ) ); } - else if (primNumVerts <= state.m_numIndices) + else if (prim.m_min <= state.m_numIndices) { numIndices = state.m_numIndices; - numPrimsSubmitted = numIndices/primNumVerts; + numPrimsSubmitted = numIndices/prim.m_div - prim.m_sub; numInstances = state.m_numInstances; numPrimsRendered = numPrimsSubmitted*state.m_numInstances; - GL_CHECK(glDrawElementsInstanced(primType + GL_CHECK(glDrawElementsInstanced(prim.m_type , numIndices , GL_UNSIGNED_SHORT , (void*)(uintptr_t)(state.m_startIndex*2) @@ -4287,21 +4311,21 @@ namespace bgfx } else { - numPrimsSubmitted = numVertices/primNumVerts; + numPrimsSubmitted = numVertices/prim.m_div - prim.m_sub; numInstances = state.m_numInstances; numPrimsRendered = numPrimsSubmitted*state.m_numInstances; - GL_CHECK(glDrawArraysInstanced(primType + GL_CHECK(glDrawArraysInstanced(prim.m_type , 0 , numVertices , state.m_numInstances ) ); } - statsNumPrimsSubmitted += numPrimsSubmitted; + statsNumPrimsSubmitted[primIndex] += numPrimsSubmitted; + statsNumPrimsRendered[primIndex] += numPrimsRendered; + statsNumInstances[primIndex] += numInstances; statsNumIndices += numIndices; - statsNumInstances += numInstances; - statsNumPrimsRendered += numPrimsRendered; } } } @@ -4377,19 +4401,23 @@ namespace bgfx , elapsedCpuMs > elapsedGpuMs ? '>' : '<' , elapsedGpuMs ); - tvm.printf(10, pos++, 0x8e, " Prims: %7d (#inst: %5d), submitted: %7d" - , statsNumPrimsRendered - , statsNumInstances - , statsNumPrimsSubmitted - ); - - double captureMs = double(captureElapsed)*toMs; - tvm.printf(10, pos++, 0x8e, " Capture: %3.4f [ms]", captureMs); + for (uint32_t ii = 0; ii < BX_COUNTOF(s_primInfo); ++ii) + { + tvm.printf(10, pos++, 0x8e, " %8s: %7d (#inst: %5d), submitted: %7d" + , s_primName[ii] + , statsNumPrimsRendered[ii] + , statsNumInstances[ii] + , statsNumPrimsSubmitted[ii] + ); + } tvm.printf(10, pos++, 0x8e, " Indices: %7d", statsNumIndices); tvm.printf(10, pos++, 0x8e, " DVB size: %7d", m_render->m_vboffset); tvm.printf(10, pos++, 0x8e, " DIB size: %7d", m_render->m_iboffset); + double captureMs = double(captureElapsed)*toMs; + tvm.printf(10, pos++, 0x8e, " Capture: %3.4f [ms]", captureMs); + #if BGFX_CONFIG_RENDERER_OPENGL if (s_extension[Extension::ATI_meminfo].m_supported) { diff --git a/tools/shaderc/shaderc.cpp b/tools/shaderc/shaderc.cpp index 5b85c51b..5a07664b 100644 --- a/tools/shaderc/shaderc.cpp +++ b/tools/shaderc/shaderc.cpp @@ -265,20 +265,18 @@ static const UniformRemapDx9 s_constRemapDx9[7] = { UniformType::Uniform2fv, D3DXPC_VECTOR, D3DXPT_FLOAT, 8 }, { UniformType::Uniform3fv, D3DXPC_VECTOR, D3DXPT_FLOAT, 12 }, { UniformType::Uniform4fv, D3DXPC_VECTOR, D3DXPT_FLOAT, 16 }, - { UniformType::Uniform3x3fv, D3DXPC_MATRIX_COLUMNS, D3DXPT_FLOAT, 36 }, + { UniformType::Uniform3x3fv, D3DXPC_MATRIX_COLUMNS, D3DXPT_FLOAT, 48 }, { UniformType::Uniform4x4fv, D3DXPC_MATRIX_COLUMNS, D3DXPT_FLOAT, 64 }, }; UniformType::Enum findUniformTypeDx9(const D3DXCONSTANT_DESC& constDesc) { - uint32_t count = sizeof(s_constRemapDx9)/sizeof(UniformRemapDx9); - for (uint32_t ii = 0; ii < count; ++ii) + for (uint32_t ii = 0; ii < BX_COUNTOF(s_constRemapDx9); ++ii) { const UniformRemapDx9& remap = s_constRemapDx9[ii]; if (remap.paramClass == constDesc.Class - && remap.paramType == constDesc.Type - && (constDesc.Bytes%remap.paramBytes) == 0) + && remap.paramType == constDesc.Type) { return remap.id; } @@ -314,16 +312,14 @@ static const UniformRemapDx11 s_constRemapDx11[7] = { UniformType::Uniform4x4fv, D3D_SVC_MATRIX_COLUMNS, D3D_SVT_FLOAT, 64 }, }; -UniformType::Enum findUniformTypeDx11(const D3D11_SHADER_TYPE_DESC& constDesc, uint32_t _size) +UniformType::Enum findUniformTypeDx11(const D3D11_SHADER_TYPE_DESC& constDesc) { - uint32_t count = sizeof(s_constRemapDx11)/sizeof(UniformRemapDx9); - for (uint32_t ii = 0; ii < count; ++ii) + for (uint32_t ii = 0; ii < BX_COUNTOF(s_constRemapDx11); ++ii) { const UniformRemapDx11& remap = s_constRemapDx11[ii]; if (remap.paramClass == constDesc.Class - && remap.paramType == constDesc.Type - && (_size%remap.paramBytes) == 0) + && remap.paramType == constDesc.Type) { return remap.id; } @@ -809,6 +805,8 @@ bool compileGLSLShader(bx::CommandLine& _cmdLine, uint32_t _gles, const std::str bool compileHLSLShaderDx9(bx::CommandLine& _cmdLine, const std::string& _code, bx::WriterI* _writer) { #if BX_PLATFORM_WINDOWS + BX_TRACE("DX9"); + const char* profile = _cmdLine.findOption('p', "profile"); if (NULL == profile) { @@ -1030,6 +1028,8 @@ bool compileHLSLShaderDx9(bx::CommandLine& _cmdLine, const std::string& _code, b bool compileHLSLShaderDx11(bx::CommandLine& _cmdLine, const std::string& _code, bx::WriterI* _writer) { #if BX_PLATFORM_WINDOWS + BX_TRACE("DX11"); + const char* profile = _cmdLine.findOption('p', "profile"); if (NULL == profile) { @@ -1207,7 +1207,7 @@ bool compileHLSLShaderDx11(bx::CommandLine& _cmdLine, const std::string& _code, hr = type->GetDesc(&constDesc); if (SUCCEEDED(hr) ) { - UniformType::Enum type = findUniformTypeDx11(constDesc, varDesc.Size); + UniformType::Enum type = findUniformTypeDx11(constDesc); if (UniformType::Count != type && 0 != (varDesc.uFlags & D3D_SVF_USED) ) @@ -1228,6 +1228,10 @@ bool compileHLSLShaderDx11(bx::CommandLine& _cmdLine, const std::string& _code, , type ); } + else + { + BX_TRACE("\t%s, unknown type", varDesc.Name); + } } } }