diff options
Diffstat (limited to 'Runtime/GfxDevice/d3d11/D3D11VBO.cpp')
| -rw-r--r-- | Runtime/GfxDevice/d3d11/D3D11VBO.cpp | 1193 |
1 files changed, 1193 insertions, 0 deletions
diff --git a/Runtime/GfxDevice/d3d11/D3D11VBO.cpp b/Runtime/GfxDevice/d3d11/D3D11VBO.cpp new file mode 100644 index 0000000..e0beaf1 --- /dev/null +++ b/Runtime/GfxDevice/d3d11/D3D11VBO.cpp @@ -0,0 +1,1193 @@ +#include "UnityPrefix.h" +#include "D3D11VBO.h" +#include "D3D11Context.h" +#include "Runtime/GfxDevice/GfxDevice.h" +#include "Runtime/Graphics/TriStripper.h" +#include "Runtime/GfxDevice/ChannelAssigns.h" +#include "Runtime/Utilities/ArrayUtility.h" +#include "D3D11Utils.h" + + + +// defined in GfxDeviceD3D11.cpp +ID3D11InputLayout* GetD3D11VertexDeclaration (const ChannelInfoArray& channels); +void UpdateChannelBindingsD3D11 (const ChannelAssigns& channels); + +ID3D11InputLayout* g_ActiveInputLayoutD3D11; +D3D11_PRIMITIVE_TOPOLOGY g_ActiveTopologyD3D11 = D3D11_PRIMITIVE_TOPOLOGY_UNDEFINED; + + + +static const D3D11_PRIMITIVE_TOPOLOGY kTopologyD3D11[kPrimitiveTypeCount] = +{ + D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST, + D3D11_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP, + D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST, + D3D11_PRIMITIVE_TOPOLOGY_LINELIST, + D3D11_PRIMITIVE_TOPOLOGY_LINESTRIP, + D3D11_PRIMITIVE_TOPOLOGY_POINTLIST, +}; + +static const D3D11_PRIMITIVE_TOPOLOGY kTopologyD3D11Tess[kPrimitiveTypeCount] = +{ + D3D11_PRIMITIVE_TOPOLOGY_3_CONTROL_POINT_PATCHLIST, + D3D11_PRIMITIVE_TOPOLOGY_UNDEFINED, + D3D11_PRIMITIVE_TOPOLOGY_4_CONTROL_POINT_PATCHLIST, + D3D11_PRIMITIVE_TOPOLOGY_2_CONTROL_POINT_PATCHLIST, + D3D11_PRIMITIVE_TOPOLOGY_UNDEFINED, + D3D11_PRIMITIVE_TOPOLOGY_1_CONTROL_POINT_PATCHLIST, +}; + + +void SetInputLayoutD3D11 (ID3D11DeviceContext* ctx, ID3D11InputLayout* layout) +{ + if (g_ActiveInputLayoutD3D11 != layout) + { + g_ActiveInputLayoutD3D11 = layout; + D3D11_CALL (ctx->IASetInputLayout (layout)); + } +} + + +static ID3D11InputLayout* GetD3D11VertexDeclaration (UInt32 shaderChannelsMap) +{ + ChannelInfoArray channels; + int offset = 0; + for (int i = 0; i < kShaderChannelCount; i++) + { + ChannelInfo& info = channels[i]; + if (shaderChannelsMap & (1 << i)) + { + info.stream = 0; + info.offset = offset; + info.format = VBO::GetDefaultChannelFormat( i ); + info.dimension = VBO::GetDefaultChannelDimension( i ); + offset += VBO::GetDefaultChannelByteSize( i ); + } + else + info.Reset(); + } + return GetD3D11VertexDeclaration (channels); +} + + +// ----------------------------------------------------------------------------- + +ID3D11Buffer* D3D11VBO::ms_CustomIB = NULL; +int D3D11VBO::ms_CustomIBSize = 0; +UInt32 D3D11VBO::ms_CustomIBUsedBytes = 0; + +ID3D11Buffer* D3D11VBO::ms_AllWhiteBuffer = NULL; + + +D3D11VBO::D3D11VBO() +: m_IB(NULL) +, m_StagingIB(NULL) +, m_IBReadable(NULL) +, m_IBSize(0) +, m_useForSO(false) +{ + memset(m_VBStreams, 0, sizeof(m_VBStreams)); + memset(m_StagingVB, 0, sizeof(m_StagingVB)); +} + +D3D11VBO::~D3D11VBO () +{ + for (int s = 0; s < kMaxVertexStreams; ++s) + { + //std::string tmp = GetDebugNameD3D11(m_StagingVB[s]); + REGISTER_EXTERNAL_GFX_DEALLOCATION(m_VBStreams[s]); + REGISTER_EXTERNAL_GFX_DEALLOCATION(m_StagingVB[s]); + SAFE_RELEASE(m_VBStreams[s]); + SAFE_RELEASE(m_StagingVB[s]); + } + if (m_IB) + { + REGISTER_EXTERNAL_GFX_DEALLOCATION(m_IB); + SAFE_RELEASE(m_IB); + } + if (m_StagingIB) + { + REGISTER_EXTERNAL_GFX_DEALLOCATION(m_StagingIB); + SAFE_RELEASE(m_StagingIB); + } + delete[] m_IBReadable; +} + + +static ID3D11Buffer* CreateStagingBuffer (int size) +{ + ID3D11Device* dev = GetD3D11Device(); + D3D11_BUFFER_DESC desc; + desc.ByteWidth = size; + desc.Usage = D3D11_USAGE_STAGING; + desc.BindFlags = 0; + desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE; + desc.MiscFlags = 0; + desc.StructureByteStride = 0; + + ID3D11Buffer* buffer = NULL; + HRESULT hr = dev->CreateBuffer (&desc, NULL, &buffer); + REGISTER_EXTERNAL_GFX_ALLOCATION_REF(buffer,size,NULL); + AssertIf (FAILED(hr)); + return buffer; +} + +void D3D11VBO::CleanupSharedBuffers() +{ + REGISTER_EXTERNAL_GFX_DEALLOCATION(ms_CustomIB); + REGISTER_EXTERNAL_GFX_DEALLOCATION(ms_AllWhiteBuffer); + SAFE_RELEASE (ms_CustomIB); + SAFE_RELEASE (ms_AllWhiteBuffer); + ms_CustomIBSize = 0; + ms_CustomIBUsedBytes = 0; +} + + +void D3D11VBO::UpdateVertexStream (const VertexBufferData& sourceData, unsigned stream) +{ + DebugAssert (!m_IsStreamMapped[stream]); + const StreamInfo& srcStream = sourceData.streams[stream]; + const int oldSize = CalculateVertexStreamSize(m_Streams[stream], m_VertexCount); + +#if UNITY_METRO + #pragma message("Fix ugly hack CreateStagingBuffer") + // So honestly I don't how what's happening here, but when running on ARM (Surface) with Feature Level 9.1 and if we create a vertex buffer with size 144 + // Sometimes we crash in D3D11VBO dtor in this line SAFE_RELEASE(m_StagingVB[s]); + // Sometimes we get an access violation but sometimes it's Data misalignment exception like below + // First-chance exception at 0x75499B2A (setupapi.dll) in Drift Mania Championship 2.exe: 0x80000002: Datatype misalignment + // Repro case 495782 + // Not reproducible on Win32 running Feature Level 9.1 + + // In any case it seems increasing min size up to 256, solves this issue for now + int newSize = CalculateVertexStreamSize(srcStream, sourceData.vertexCount); + int addon = 1; + while (newSize > 0 && newSize < 256) + { + newSize = CalculateVertexStreamSize(srcStream, sourceData.vertexCount + addon); + addon++; + } + +#else + const int newSize = CalculateVertexStreamSize(srcStream, sourceData.vertexCount); +#endif + + + m_Streams[stream] = srcStream; + if (newSize == 0) + { + REGISTER_EXTERNAL_GFX_DEALLOCATION(m_VBStreams[stream]); + REGISTER_EXTERNAL_GFX_DEALLOCATION(m_StagingVB[stream]); + SAFE_RELEASE (m_VBStreams[stream]); + SAFE_RELEASE (m_StagingVB[stream]); + return; + } + + const bool isDynamic = (m_StreamModes[stream] == kStreamModeDynamic); + const bool useStaging = !isDynamic; + + if (m_VBStreams[stream] == NULL || newSize != oldSize) + { + REGISTER_EXTERNAL_GFX_DEALLOCATION(m_VBStreams[stream]); + REGISTER_EXTERNAL_GFX_DEALLOCATION(m_StagingVB[stream]); + SAFE_RELEASE (m_VBStreams[stream]); + SAFE_RELEASE (m_StagingVB[stream]); // release staging VB as well here + + ID3D11Device* dev = GetD3D11Device(); + D3D11_BUFFER_DESC desc; + desc.ByteWidth = newSize; + desc.Usage = isDynamic ? D3D11_USAGE_DYNAMIC : D3D11_USAGE_DEFAULT; + desc.BindFlags = D3D11_BIND_VERTEX_BUFFER; + if ( m_useForSO ) + desc.BindFlags |= D3D11_BIND_STREAM_OUTPUT; + desc.CPUAccessFlags = isDynamic ? D3D11_CPU_ACCESS_WRITE : 0; + desc.MiscFlags = 0; + desc.StructureByteStride = 0; + HRESULT hr = dev->CreateBuffer (&desc, NULL, &m_VBStreams[stream]); + REGISTER_EXTERNAL_GFX_ALLOCATION_REF(m_VBStreams[stream],newSize,this); + if (FAILED(hr)) + { + printf_console ("d3d11: failed to create vertex buffer of size %d [0x%X]\n", newSize, hr); + return; + } + SetDebugNameD3D11 (m_VBStreams[stream], Format("VertexBuffer-%d", newSize)); + + if (useStaging) + { + m_StagingVB[stream] = CreateStagingBuffer (newSize); + SetDebugNameD3D11 (m_StagingVB[stream], Format("StagingVertexBuffer-%d", newSize)); + } + } + + // Don't update contents if there is no source data. + // This is used to update the vertex declaration only, leaving buffer intact. + // Also to create an empty buffer that is written to later. + if (!sourceData.buffer) + return; + + HRESULT hr; + + ID3D11Buffer* mapVB = NULL; + D3D11_MAP mapType; + + if (useStaging) + { + mapVB = m_StagingVB[stream]; + mapType = D3D11_MAP_WRITE; + } + else + { + mapVB = m_VBStreams[stream]; + mapType = D3D11_MAP_WRITE_DISCARD; + } + + Assert (mapVB); + + ID3D11DeviceContext* ctx = GetD3D11Context(); + + D3D11_MAPPED_SUBRESOURCE mapped; + hr = ctx->Map (mapVB, 0, mapType, 0, &mapped); + Assert (SUCCEEDED(hr)); + CopyVertexStream (sourceData, reinterpret_cast<UInt8*>(mapped.pData), stream); + ctx->Unmap (mapVB, 0); + + if (useStaging) + ctx->CopyResource (m_VBStreams[stream], m_StagingVB[stream]); +} + + +void D3D11VBO::UpdateIndexBufferData (const IndexBufferData& sourceData) +{ + if( !sourceData.indices ) + { + m_IBSize = 0; + return; + } + + Assert (m_IB); + HRESULT hr; + + int size = sourceData.count * kVBOIndexSize; + if (sourceData.hasTopologies & ((1<<kPrimitiveTriangleStripDeprecated) | (1<<kPrimitiveQuads))) + { + delete[] m_IBReadable; + m_IBReadable = new UInt16[sourceData.count]; + memcpy (m_IBReadable, sourceData.indices, size); + } + + const D3D11_MAP mapType = m_IndicesDynamic ? D3D11_MAP_WRITE_DISCARD : D3D11_MAP_WRITE; + ID3D11Buffer* mapIB; + if (m_IndicesDynamic) + mapIB = m_IB; + else + { + if (!m_StagingIB) + m_StagingIB = CreateStagingBuffer(m_IBSize); + mapIB = m_StagingIB; + } + + ID3D11DeviceContext* ctx = GetD3D11Context(); + D3D11_MAPPED_SUBRESOURCE mapped; + hr = ctx->Map (mapIB, 0, mapType, 0, &mapped); + Assert (SUCCEEDED(hr)); + + memcpy (mapped.pData, sourceData.indices, size); + + ctx->Unmap (mapIB, 0); + if (!m_IndicesDynamic) + ctx->CopyResource (m_IB, m_StagingIB); +} + +bool D3D11VBO::MapVertexStream( VertexStreamData& outData, unsigned stream ) +{ + if (m_VBStreams[stream] == NULL) + { + printf_console ("d3d11: attempt to map null vertex buffer\n"); + return false; + } + DebugAssert(!IsVertexBufferLost()); + Assert(!m_IsStreamMapped[stream]); + + const int vbSize = CalculateVertexStreamSize(m_Streams[stream], m_VertexCount); + + const bool dynamic = (m_StreamModes[stream]==kStreamModeDynamic); + + D3D11_MAPPED_SUBRESOURCE mapped; + ID3D11Buffer* mapVB = dynamic ? m_VBStreams[stream] : m_StagingVB[stream]; + D3D11_MAP mapType = dynamic ? D3D11_MAP_WRITE_DISCARD : D3D11_MAP_WRITE; + HRESULT hr = GetD3D11Context()->Map (mapVB, 0, mapType, 0, &mapped); + if( FAILED(hr) ) + { + printf_console ("d3d11: failed to map vertex buffer %p of size %i [%x]\n", mapVB, vbSize, hr); + return false; + } + m_IsStreamMapped[stream] = true; + + UInt8* buffer = (UInt8*)mapped.pData; + + outData.buffer = buffer; + outData.channelMask = m_Streams[stream].channelMask; + outData.stride = m_Streams[stream].stride; + outData.vertexCount = m_VertexCount; + + GetRealGfxDevice().GetFrameStats().AddUploadVBO(vbSize); + + return true; +} + +void D3D11VBO::UnmapVertexStream (unsigned stream) +{ + DebugAssert(m_VBStreams[stream]); + Assert(m_IsStreamMapped[stream]); + m_IsStreamMapped[stream] = false; + ID3D11DeviceContext* ctx = GetD3D11Context(); + + const bool dynamic = (m_StreamModes[stream]==kStreamModeDynamic); + ID3D11Buffer* mapVB = dynamic ? m_VBStreams[stream] : m_StagingVB[stream]; + ctx->Unmap (mapVB, 0); + + if (!dynamic) + ctx->CopyResource (m_VBStreams[stream], m_StagingVB[stream]); +} + +bool D3D11VBO::IsVertexBufferLost() const +{ + for (int s = 0; s < kMaxVertexStreams; ++s) + if (m_Streams[s].channelMask && !m_VBStreams[s]) + return true; + return false; +} + +int D3D11VBO::GetRuntimeMemorySize() const +{ + int vertexSize = 0; + for( int s = 0; s < kMaxVertexStreams; s++ ) + vertexSize += m_Streams[s].stride; + return vertexSize * m_VertexCount + m_IBSize; +} + + +bool SetTopologyD3D11 (GfxPrimitiveType topology, GfxDevice& device, ID3D11DeviceContext* ctx) +{ + bool tessellation = device.IsShaderActive (kShaderHull) || device.IsShaderActive (kShaderDomain); + D3D11_PRIMITIVE_TOPOLOGY topod3d = tessellation ? kTopologyD3D11Tess[topology] : kTopologyD3D11[topology]; + if (topod3d == D3D11_PRIMITIVE_TOPOLOGY_UNDEFINED) + return false; + + if (topod3d != g_ActiveTopologyD3D11) + { + g_ActiveTopologyD3D11 = topod3d; + D3D11_CALL (ctx->IASetPrimitiveTopology (topod3d)); + } + return true; +} + + +ID3D11Buffer* D3D11VBO::GetAllWhiteBuffer() +{ + if (!ms_AllWhiteBuffer) + { + int maxVerts = 0x10000; + int size = maxVerts * sizeof(UInt32); + UInt8* data = new UInt8[size]; + memset (data, 0xFF, size); + + D3D11_BUFFER_DESC desc; + desc.ByteWidth = size; + desc.Usage = D3D11_USAGE_IMMUTABLE; + desc.BindFlags = D3D11_BIND_VERTEX_BUFFER; + desc.CPUAccessFlags = 0; + desc.MiscFlags = 0; + desc.StructureByteStride = 0; + D3D11_SUBRESOURCE_DATA sdata; + sdata.pSysMem = data; + sdata.SysMemPitch = 0; + sdata.SysMemSlicePitch = 0; + HRESULT hr = GetD3D11Device()->CreateBuffer (&desc, &sdata, &ms_AllWhiteBuffer); + REGISTER_EXTERNAL_GFX_ALLOCATION_REF(ms_AllWhiteBuffer,size,NULL); + delete[] data; + } + return ms_AllWhiteBuffer; +} + + +void D3D11VBO::BindVertexStreams(GfxDevice& device, ID3D11DeviceContext* ctx, const ChannelAssigns& channels) +{ + DX11_LOG_ENTER_FUNCTION("D3D11VBO::BindVertexStreams"); + int freeStream = -1; + for (int s = 0; s < kMaxVertexStreams; ++s) + { + if (m_VBStreams[s]) + { + UINT offset = 0; + UINT stride = m_Streams[s].stride; + D3D11_CALL (ctx->IASetVertexBuffers(s, 1, &m_VBStreams[s], &stride, &offset)); + } + else + freeStream = s; + } + + UpdateChannelBindingsD3D11(channels); + + device.BeforeDrawCall( false ); + + const ChannelInfoArray* channelInfo = &m_ChannelInfo; + if ((channels.GetSourceMap() & VERTEX_FORMAT1(Color)) && !m_ChannelInfo[kShaderChannelColor].IsValid()) + { + if (freeStream != -1) + { + static ChannelInfoArray colorChannelInfo; + memcpy(&colorChannelInfo, m_ChannelInfo, sizeof(colorChannelInfo)); + ChannelInfo& colorInfo = colorChannelInfo[kShaderChannelColor]; + colorInfo.stream = freeStream; + colorInfo.offset = 0; + colorInfo.format = kChannelFormatColor; + colorInfo.dimension = 1; + channelInfo = &colorChannelInfo; + ID3D11Buffer* whiteVB = GetAllWhiteBuffer(); + UINT stride = 4; + UINT offset = 0; + D3D11_CALL (ctx->IASetVertexBuffers(freeStream, 1, &whiteVB, &stride, &offset)); + } + else + ErrorString("Need a free stream to add default vertex colors!"); + } + ID3D11InputLayout* inputLayout = GetD3D11VertexDeclaration(m_ChannelInfo); + SetInputLayoutD3D11 (ctx, inputLayout); +} + +void D3D11VBO::BindToStreamOutput() +{ + const UINT offsets[] = { 0 }; + GetD3D11Context()->SOSetTargets(1, m_VBStreams, offsets); +} + +void D3D11VBO::UnbindFromStreamOutput() +{ + ID3D11Buffer* const buffers[] = { 0 }; + const UINT offsets[] = { 0 }; + GetD3D11Context()->SOSetTargets(1, buffers, offsets); +} + + +void D3D11VBO::DrawVBO (const ChannelAssigns& channels, UInt32 firstIndexByte, UInt32 indexCount, GfxPrimitiveType topology, UInt32 firstVertex, UInt32 vertexCount) +{ + DX11_LOG_ENTER_FUNCTION("D3D11VBO::DrawVBO"); + // just return if no indices + if( m_IBSize == 0 ) + return; + + Assert(!m_IsStreamMapped[0]); + if (m_VBStreams[0] == 0 || m_IB == 0) + { + printf_console( "d3d: VB or IB is null\n" ); + return; + } + + GfxDevice& device = GetRealGfxDevice(); + ID3D11DeviceContext* ctx = GetD3D11Context(); + BindVertexStreams (device, ctx, channels); + + bool tessellation = device.IsShaderActive (kShaderHull) || device.IsShaderActive (kShaderDomain); + if (tessellation && topology == kPrimitiveTriangleStripDeprecated) + { + if (!m_IBReadable) + return; + + const UInt16* ibSrc = (const UInt16*)((const UInt8*)m_IBReadable + firstIndexByte); + const int triCount = CountTrianglesInStrip (ibSrc, indexCount); + + UInt32 ibBytesLocked; + UInt16* ibPtr = MapDynamicIndexBuffer (triCount*3, ibBytesLocked); + if (!ibPtr) + return; + Destripify (ibSrc, indexCount, ibPtr, triCount*3); + UnmapDynamicIndexBuffer (); + firstIndexByte = ms_CustomIBUsedBytes; + ms_CustomIBUsedBytes += ibBytesLocked; + D3D11_CALL (ctx->IASetIndexBuffer (ms_CustomIB, DXGI_FORMAT_R16_UINT, 0)); + indexCount = ibBytesLocked/kVBOIndexSize; + topology = kPrimitiveTriangles; + } + else if (topology == kPrimitiveQuads && !tessellation) + { + if (!m_IBReadable) + return; + UInt32 ibBytesLocked; + UInt16* ibPtr = MapDynamicIndexBuffer (indexCount/4*6, ibBytesLocked); + if (!ibPtr) + return; + const UInt16* ibSrc = (const UInt16*)((const UInt8*)m_IBReadable + firstIndexByte); + FillIndexBufferForQuads (ibPtr, ibBytesLocked, ibSrc, indexCount/4); + UnmapDynamicIndexBuffer (); + firstIndexByte = ms_CustomIBUsedBytes; + ms_CustomIBUsedBytes += ibBytesLocked; + D3D11_CALL (ctx->IASetIndexBuffer (ms_CustomIB, DXGI_FORMAT_R16_UINT, 0)); + indexCount = ibBytesLocked/kVBOIndexSize; + } + else + { + D3D11_CALL (ctx->IASetIndexBuffer (m_IB, DXGI_FORMAT_R16_UINT, 0)); + } + + // draw + if (!SetTopologyD3D11 (topology, device, ctx)) + return; + D3D11_CALL (ctx->DrawIndexed (indexCount, firstIndexByte/2, 0)); + device.GetFrameStats().AddDrawCall (GetPrimitiveCount(indexCount,topology,false), vertexCount); + DX11_MARK_DRAWING(GetPrimitiveCount(indexCount,topology,false), vertexCount); + +} + +UInt16* D3D11VBO::MapDynamicIndexBuffer (int indexCount, UInt32& outBytesUsed) +{ + HRESULT hr; + const UInt32 maxIndices = 64000; + Assert (indexCount <= maxIndices); + indexCount = std::min<UInt32>(indexCount, maxIndices); + + int ibCapacity = indexCount * kVBOIndexSize; + int newIBSize = std::max (ibCapacity, 32*1024); // 32k IB at least + + if (newIBSize > ms_CustomIBSize) + { + if (ms_CustomIB) + { + REGISTER_EXTERNAL_GFX_DEALLOCATION(ms_CustomIB); + ms_CustomIB->Release(); + } + ms_CustomIBSize = newIBSize; + ms_CustomIBUsedBytes = 0; + + ID3D11Device* dev = GetD3D11Device(); + + D3D11_BUFFER_DESC desc; + desc.ByteWidth = newIBSize; + desc.Usage = D3D11_USAGE_DYNAMIC; + desc.BindFlags = D3D11_BIND_INDEX_BUFFER; + desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE; + desc.MiscFlags = 0; + desc.StructureByteStride = 0; + hr = dev->CreateBuffer (&desc, NULL, &ms_CustomIB); + REGISTER_EXTERNAL_GFX_ALLOCATION_REF(ms_CustomIB,newIBSize,NULL); + if (FAILED(hr)) + { + printf_console ("d3d11: failed to create custom index buffer of size %d [%x]\n", newIBSize, hr); + return NULL; + } + SetDebugNameD3D11 (ms_CustomIB, Format("IndexBufferCustomDynamic-%d", newIBSize)); + } + + ID3D11DeviceContext* ctx = GetD3D11Context(); + D3D11_MAPPED_SUBRESOURCE mapped; + if (ms_CustomIBUsedBytes + ibCapacity > ms_CustomIBSize) + { + hr = ctx->Map (ms_CustomIB, 0, D3D11_MAP_WRITE_DISCARD, 0, &mapped); + if (FAILED(hr)) + { + printf_console ("d3d11: failed to lock shared index buffer with discard [%x]\n", hr); + return NULL; + } + ms_CustomIBUsedBytes = 0; + } + else + { + hr = ctx->Map (ms_CustomIB, 0, D3D11_MAP_WRITE_NO_OVERWRITE, 0, &mapped); + if (FAILED(hr)) + { + printf_console( "d3d11: failed to lock shared index buffer, offset %i size %i [%x]\n", ms_CustomIBUsedBytes, ibCapacity, hr); + return NULL; + } + } + outBytesUsed = ibCapacity; + + return (UInt16*)((UInt8*)mapped.pData + ms_CustomIBUsedBytes); +} + +void D3D11VBO::UnmapDynamicIndexBuffer () +{ + GetD3D11Context()->Unmap (ms_CustomIB, 0); +} + + +#if GFX_ENABLE_DRAW_CALL_BATCHING +void D3D11VBO::DrawCustomIndexed( const ChannelAssigns& channels, void* indices, UInt32 indexCount, + GfxPrimitiveType topology, UInt32 vertexRangeBegin, UInt32 vertexRangeEnd, UInt32 drawVertexCount ) +{ + HRESULT hr; + Assert (!m_IsStreamMapped[0]); + + if (m_VBStreams[0] == 0) + { + printf_console( "d3d11: VB is null\n" ); + return; + } + + ID3D11DeviceContext* ctx = GetD3D11Context(); + + UInt32 ibBytesUsed; + UInt16* ibPtr = MapDynamicIndexBuffer (indexCount, ibBytesUsed); + if (!ibPtr) + return; + memcpy (ibPtr, indices, ibBytesUsed); + UnmapDynamicIndexBuffer (); + + // draw + GfxDevice& device = GetRealGfxDevice(); + BindVertexStreams(device, ctx, channels); + + D3D11_CALL (ctx->IASetIndexBuffer (ms_CustomIB, DXGI_FORMAT_R16_UINT, 0)); + + // draw + if (!SetTopologyD3D11 (topology, device, ctx)) + return; + D3D11_CALL (ctx->DrawIndexed (indexCount, ms_CustomIBUsedBytes / kVBOIndexSize, 0)); + device.GetFrameStats().AddDrawCall (GetPrimitiveCount(indexCount,topology,false), drawVertexCount); + + ms_CustomIBUsedBytes += ibBytesUsed; +} + +#endif // GFX_ENABLE_DRAW_CALL_BATCHING + + + +void D3D11VBO::UpdateVertexData( const VertexBufferData& buffer ) +{ + for (unsigned stream = 0; stream < kMaxVertexStreams; stream++) + UpdateVertexStream (buffer, stream); + + memcpy (m_ChannelInfo, buffer.channels, sizeof(m_ChannelInfo)); + m_VertexCount = buffer.vertexCount; +} + +void D3D11VBO::UpdateIndexData (const IndexBufferData& buffer) +{ + int newSize = CalculateIndexBufferSize(buffer); + + // If we have old buffer, but need different size: delete old one + if (newSize != m_IBSize) + { + if (m_IB) + { + REGISTER_EXTERNAL_GFX_DEALLOCATION(m_IB); + SAFE_RELEASE(m_IB); + } + if (m_StagingIB) + { + REGISTER_EXTERNAL_GFX_DEALLOCATION(m_StagingIB); + SAFE_RELEASE(m_StagingIB); + } + } + + // Create buffer if we need to + if (!m_IB) + { + ID3D11Device* dev = GetD3D11Device(); + D3D11_BUFFER_DESC desc; + desc.ByteWidth = newSize; + desc.Usage = m_IndicesDynamic ? D3D11_USAGE_DYNAMIC : D3D11_USAGE_DEFAULT; + desc.BindFlags = D3D11_BIND_INDEX_BUFFER; + desc.CPUAccessFlags = m_IndicesDynamic ? D3D11_CPU_ACCESS_WRITE : 0; + desc.MiscFlags = 0; + desc.StructureByteStride = 0; + HRESULT hr = dev->CreateBuffer (&desc, NULL, &m_IB); + REGISTER_EXTERNAL_GFX_ALLOCATION_REF(m_IB,newSize,this); + if( FAILED(hr) ) + { + printf_console( "d3d11: failed to create index buffer of size %d [0x%X]\n", newSize, hr ); + return; + } + SetDebugNameD3D11 (m_IB, Format("IndexBuffer-%d", newSize)); + } + + m_IBSize = newSize; + UpdateIndexBufferData(buffer); +} + +void D3D11VBO::SetIndicesDynamic(bool dynamic) +{ + // do nothing if a no-op + if (dynamic == m_IndicesDynamic) + return; + + VBO::SetIndicesDynamic(dynamic); + + // release current index buffers + if (m_IB) + { + REGISTER_EXTERNAL_GFX_DEALLOCATION(m_IB); + SAFE_RELEASE(m_IB); + } + if (m_StagingIB) + { + REGISTER_EXTERNAL_GFX_DEALLOCATION(m_StagingIB); + SAFE_RELEASE(m_StagingIB); + } +} + + + +// ----------------------------------------------------------------------------- + + +DynamicD3D11VBO::DynamicD3D11VBO( UInt32 vbSize, UInt32 ibSize ) +: DynamicVBO() +, m_VBSize(vbSize) +, m_VBUsedBytes(0) +, m_IBSize(ibSize) +, m_IBUsedBytes(0) +, m_VB(NULL) +, m_IB(NULL) +, m_LastChunkStartVertex(0) +, m_LastChunkStartIndex(0) +, m_QuadsIB(NULL) +{ +} + +DynamicD3D11VBO::~DynamicD3D11VBO () +{ + if( m_VB ) { + REGISTER_EXTERNAL_GFX_DEALLOCATION(m_VB); + ULONG refCount = m_VB->Release(); + AssertIf( refCount != 0 ); + } + if( m_IB ) { + REGISTER_EXTERNAL_GFX_DEALLOCATION(m_IB); + ULONG refCount = m_IB->Release(); + AssertIf( refCount != 0 ); + } + if( m_QuadsIB ) { + REGISTER_EXTERNAL_GFX_DEALLOCATION(m_QuadsIB); + ULONG refCount = m_QuadsIB->Release(); + AssertIf( refCount != 0 ); + } +} + +void DynamicD3D11VBO::InitializeQuadsIB() +{ + AssertIf( m_QuadsIB ); + + const int kMaxQuads = 65536/4 - 4; // so we fit into 16 bit indices, minus some more just in case + + UInt16* data = new UInt16[kMaxQuads*6]; + UInt16* ib = data; + UInt32 baseIndex = 0; + for( int i = 0; i < kMaxQuads; ++i ) + { + ib[0] = baseIndex + 1; + ib[1] = baseIndex + 2; + ib[2] = baseIndex; + ib[3] = baseIndex + 2; + ib[4] = baseIndex + 3; + ib[5] = baseIndex; + baseIndex += 4; + ib += 6; + } + + ID3D11Device* dev = GetD3D11Device(); + D3D11_BUFFER_DESC desc; + desc.ByteWidth = kMaxQuads * 6 * kVBOIndexSize; + desc.Usage = D3D11_USAGE_IMMUTABLE; + desc.BindFlags = D3D11_BIND_INDEX_BUFFER; + desc.CPUAccessFlags = 0; + desc.MiscFlags = 0; + desc.StructureByteStride = 0; + D3D11_SUBRESOURCE_DATA srData; + srData.pSysMem = data; + srData.SysMemPitch = 0; + srData.SysMemSlicePitch = 0; + HRESULT hr = dev->CreateBuffer (&desc, &srData, &m_QuadsIB); + REGISTER_EXTERNAL_GFX_ALLOCATION_REF(m_QuadsIB,desc.ByteWidth,this); + delete[] data; + if (FAILED(hr)) + { + printf_console ("d3d11: failed to create quads index buffer [%x]\n", hr); + } + SetDebugNameD3D11 (m_QuadsIB, "IndexBufferQuads"); +} + + +void DynamicD3D11VBO::DrawChunk (const ChannelAssigns& channels) +{ + DX11_LOG_ENTER_FUNCTION("DynamicD3D11VBO::DrawChunk"); + // just return if nothing to render + if( !m_LastChunkShaderChannelMask ) + return; + + HRESULT hr; + + AssertIf( !m_LastChunkShaderChannelMask || !m_LastChunkStride ); + AssertIf( m_LendedChunk ); + + GfxDevice& device = GetRealGfxDevice(); + ID3D11DeviceContext* ctx = GetD3D11Context(); + + // setup VBO + DebugAssert (m_VB); + UINT strides = m_LastChunkStride; + UINT offsets = 0; + D3D11_CALL (ctx->IASetVertexBuffers(0, 1, &m_VB, &strides, &offsets)); + + UpdateChannelBindingsD3D11(channels); + device.BeforeDrawCall (false); + + ID3D11InputLayout* inputLayout = GetD3D11VertexDeclaration (m_LastChunkShaderChannelMask); + SetInputLayoutD3D11 (ctx, inputLayout); + + // draw + GfxDeviceStats& stats = device.GetFrameStats(); + int primCount = 0; + if (m_LastRenderMode == kDrawTriangleStrip) + { + if (!SetTopologyD3D11(kPrimitiveTriangleStripDeprecated,device,ctx)) + return; + D3D11_CALL (ctx->Draw (m_LastChunkVertices, m_LastChunkStartVertex)); + primCount = m_LastChunkVertices-2; + } + else if (m_LastRenderMode == kDrawIndexedTriangleStrip) + { + DebugAssert (m_IB); + if (!SetTopologyD3D11(kPrimitiveTriangleStripDeprecated,device,ctx)) + return; + D3D11_CALL (ctx->IASetIndexBuffer (m_IB, DXGI_FORMAT_R16_UINT, 0)); + D3D11_CALL (ctx->DrawIndexed (m_LastChunkIndices, m_LastChunkStartIndex, m_LastChunkStartVertex)); + primCount = m_LastChunkIndices-2; + } + else if( m_LastRenderMode == kDrawQuads ) + { + if (!SetTopologyD3D11(kPrimitiveTriangles,device,ctx)) + return; + // initialize quads index buffer if needed + if (!m_QuadsIB) + InitializeQuadsIB(); + // if quads index buffer has valid data, draw with it + if (m_QuadsIB) + { + D3D11_CALL (ctx->IASetIndexBuffer (m_QuadsIB, DXGI_FORMAT_R16_UINT, 0)); + D3D11_CALL (ctx->DrawIndexed (m_LastChunkVertices/4*6, 0, m_LastChunkStartVertex)); + primCount = m_LastChunkVertices/2; + } + } + else if (m_LastRenderMode == kDrawIndexedLines) + { + DebugAssert( m_IB ); + if (!SetTopologyD3D11(kPrimitiveLines,device,ctx)) + return; + D3D11_CALL (ctx->IASetIndexBuffer (m_IB, DXGI_FORMAT_R16_UINT, 0)); + D3D11_CALL (ctx->DrawIndexed (m_LastChunkIndices, m_LastChunkStartIndex, m_LastChunkStartVertex)); + primCount = m_LastChunkIndices/2; + } + else if (m_LastRenderMode == kDrawIndexedPoints) + { + DebugAssert (m_IB); + D3D11_CALL (ctx->IASetIndexBuffer (m_IB, DXGI_FORMAT_R16_UINT, 0)); + if (!SetTopologyD3D11 (kPrimitivePoints, device, ctx)) + return; + D3D11_CALL (ctx->DrawIndexed (m_LastChunkIndices, m_LastChunkStartIndex, m_LastChunkStartVertex)); + primCount = m_LastChunkIndices; + } + else + { + DebugAssert (m_IB); + D3D11_CALL (ctx->IASetIndexBuffer (m_IB, DXGI_FORMAT_R16_UINT, 0)); + if (!SetTopologyD3D11 (kPrimitiveTriangles, device, ctx)) + return; + D3D11_CALL (ctx->DrawIndexed (m_LastChunkIndices, m_LastChunkStartIndex, m_LastChunkStartVertex)); + primCount = m_LastChunkIndices/3; + } + stats.AddDrawCall (primCount, m_LastChunkVertices); + DX11_MARK_DRAWING(primCount, m_LastChunkVertices); +} + + +#if UNITY_EDITOR +void DynamicD3D11VBO::DrawChunkUserPrimitives (GfxPrimitiveType type) +{ + // just return if nothing to render + if( !m_LastChunkShaderChannelMask ) + return; + + HRESULT hr; + + AssertIf( !m_LastChunkShaderChannelMask || !m_LastChunkStride ); + AssertIf( m_LendedChunk ); + + ChannelAssigns channels; + for( int i = 0; i < kShaderChannelCount; ++i ) + { + if (!(m_LastChunkShaderChannelMask & (1<<i))) + continue; + VertexComponent destComponent = kSuitableVertexComponentForChannel[i]; + channels.Bind ((ShaderChannel)i, destComponent); + } + + GfxDevice& device = GetRealGfxDevice(); + ID3D11DeviceContext* ctx = GetD3D11Context(); + + // setup VBO + DebugAssert (m_VB); + UINT strides = m_LastChunkStride; + UINT offsets = 0; + D3D11_CALL (ctx->IASetVertexBuffers(0, 1, &m_VB, &strides, &offsets)); + + UpdateChannelBindingsD3D11(channels); + device.BeforeDrawCall (false); + + ID3D11InputLayout* inputLayout = GetD3D11VertexDeclaration (m_LastChunkShaderChannelMask); + SetInputLayoutD3D11 (ctx, inputLayout); + + // draw + GfxDeviceStats& stats = device.GetFrameStats(); + int primCount = 0; + switch (type) + { + case kPrimitiveTriangles: + if (!SetTopologyD3D11(kPrimitiveTriangles,device,ctx)) + return; + D3D11_CALL (ctx->Draw (m_LastChunkVertices, m_LastChunkStartVertex)); + primCount = m_LastChunkVertices/3; + break; + case kPrimitiveQuads: + if (!SetTopologyD3D11(kPrimitiveTriangles,device,ctx)) + return; + // initialize quads index buffer if needed + if (!m_QuadsIB) + InitializeQuadsIB(); + // if quads index buffer has valid data, draw with it + if (m_QuadsIB) + { + D3D11_CALL (ctx->IASetIndexBuffer (m_QuadsIB, DXGI_FORMAT_R16_UINT, 0)); + D3D11_CALL (ctx->DrawIndexed (m_LastChunkVertices/4*6, 0, m_LastChunkStartVertex)); + primCount = m_LastChunkVertices/2; + } + break; + case kPrimitiveLines: + if (!SetTopologyD3D11(kPrimitiveLines,device,ctx)) + return; + D3D11_CALL (ctx->Draw (m_LastChunkVertices, m_LastChunkStartVertex)); + primCount = m_LastChunkVertices/2; + break; + case kPrimitiveLineStrip: + if (!SetTopologyD3D11(kPrimitiveLineStrip,device,ctx)) + return; + D3D11_CALL (ctx->Draw (m_LastChunkVertices, m_LastChunkStartVertex)); + primCount = m_LastChunkVertices-1; + break; + default: + ErrorString("Primitive type not supported"); + return; + } + stats.AddDrawCall (primCount, m_LastChunkVertices); +} +#endif // UNITY_EDITOR + + +bool DynamicD3D11VBO::GetChunk( UInt32 shaderChannelMask, UInt32 maxVertices, UInt32 maxIndices, RenderMode renderMode, void** outVB, void** outIB ) +{ + Assert( !m_LendedChunk ); + Assert( maxVertices < 65536 && maxIndices < 65536*3 ); + DebugAssertMsg(outVB != NULL && maxVertices > 0, "DynamicD3D11VBO::GetChunk - outVB: 0x%08x maxVertices: %d", outVB, maxVertices); + DebugAssertMsg( + (renderMode == kDrawIndexedQuads && (outIB != NULL && maxIndices > 0)) || + (renderMode == kDrawIndexedPoints && (outIB != NULL && maxIndices > 0)) || + (renderMode == kDrawIndexedLines && (outIB != NULL && maxIndices > 0)) || + (renderMode == kDrawIndexedTriangles && (outIB != NULL && maxIndices > 0)) || + (renderMode == kDrawIndexedTriangleStrip && (outIB != NULL && maxIndices > 0)) || + (renderMode == kDrawTriangleStrip && (outIB == NULL && maxIndices == 0)) || + (renderMode == kDrawQuads && (outIB == NULL && maxIndices == 0)), + "DynamicD3D11VBO::GetChunk - renderMode: %d outIB: 0x%08x maxIndices: %d", renderMode, outIB, maxIndices); + + HRESULT hr; + bool success = true; + + m_LendedChunk = true; + m_LastChunkShaderChannelMask = shaderChannelMask; + m_LastRenderMode = renderMode; + + if( maxVertices == 0 ) + maxVertices = 8; + + m_LastChunkStride = 0; + for( int i = 0; i < kShaderChannelCount; ++i ) { + if( shaderChannelMask & (1<<i) ) + m_LastChunkStride += VBO::GetDefaultChannelByteSize(i); + } + ID3D11Device* dev = GetD3D11Device(); + ID3D11DeviceContext* ctx = GetD3D11Context(); + + // -------- vertex buffer + + DebugAssertIf( !outVB ); + UInt32 vbCapacity = maxVertices * m_LastChunkStride; + // check if requested chunk is larger than current buffer + if( vbCapacity > m_VBSize ) { + m_VBSize = vbCapacity * 2; // allocate more up front + if( m_VB ) + { + REGISTER_EXTERNAL_GFX_DEALLOCATION(m_VB); + m_VB->Release(); + } + m_VB = NULL; + } + // allocate buffer if don't have it yet + if( !m_VB ) + { + D3D11_BUFFER_DESC desc; + desc.ByteWidth = m_VBSize; + desc.Usage = D3D11_USAGE_DYNAMIC; + desc.BindFlags = D3D11_BIND_VERTEX_BUFFER; + desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE; + desc.MiscFlags = 0; + desc.StructureByteStride = 0; + hr = dev->CreateBuffer (&desc, NULL, &m_VB); + REGISTER_EXTERNAL_GFX_ALLOCATION_REF(m_VB,m_VBSize,this); + if (FAILED(hr)) + { + printf_console ("d3d11: failed to create dynamic vertex buffer of size %d [%x]\n", m_VBSize, hr); + success = false; + *outVB = NULL; + } + SetDebugNameD3D11 (m_VB, Format("VertexBufferDynamic-%d", m_VBSize)); + } + + // map, making sure the offset we lock is multiple of vertex stride + if (m_VB) + { + m_VBUsedBytes = ((m_VBUsedBytes + (m_LastChunkStride-1)) / m_LastChunkStride) * m_LastChunkStride; + if (m_VBUsedBytes + vbCapacity > m_VBSize) + { + D3D11_MAPPED_SUBRESOURCE mapped; + hr = ctx->Map (m_VB, 0, D3D11_MAP_WRITE_DISCARD, 0, &mapped); + if (FAILED(hr)) + { + printf_console ("d3d11: failed to lock dynamic vertex buffer with discard [%x]\n", hr); + *outVB = NULL; + success = false; + } + *outVB = mapped.pData; + m_VBUsedBytes = 0; + } else { + D3D11_MAPPED_SUBRESOURCE mapped; + hr = ctx->Map (m_VB, 0, D3D11_MAP_WRITE_NO_OVERWRITE, 0, &mapped); + if (FAILED(hr)) + { + printf_console ("d3d11: failed to lock vertex index buffer, offset %i size %i [%x]\n", m_VBUsedBytes, vbCapacity, hr); + *outVB = NULL; + success = false; + } + *outVB = ((UInt8*)mapped.pData) + m_VBUsedBytes; + } + m_LastChunkStartVertex = m_VBUsedBytes / m_LastChunkStride; + DebugAssertIf( m_LastChunkStartVertex * m_LastChunkStride != m_VBUsedBytes ); + } + + // -------- index buffer + + const bool indexed = (renderMode != kDrawQuads) && (renderMode != kDrawTriangleStrip); + if( success && maxIndices && indexed ) + { + UInt32 ibCapacity = maxIndices * kVBOIndexSize; + // check if requested chunk is larger than current buffer + if( ibCapacity > m_IBSize ) { + m_IBSize = ibCapacity * 2; // allocate more up front + if( m_IB ) + { + REGISTER_EXTERNAL_GFX_DEALLOCATION(m_IB); + m_IB->Release(); + } + m_IB = NULL; + } + // allocate buffer if don't have it yet + if( !m_IB ) + { + D3D11_BUFFER_DESC desc; + desc.ByteWidth = m_IBSize; + desc.Usage = D3D11_USAGE_DYNAMIC; + desc.BindFlags = D3D11_BIND_INDEX_BUFFER; + desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE; + desc.MiscFlags = 0; + desc.StructureByteStride = 0; + hr = dev->CreateBuffer (&desc, NULL, &m_IB); + REGISTER_EXTERNAL_GFX_ALLOCATION_REF(m_IB,m_IBSize,this); + if (FAILED(hr)) + { + printf_console ("d3d11: failed to create dynamic index buffer of size %d [%x]\n", m_IBSize, hr); + if (m_VB) + ctx->Unmap (m_VB, 0); + } + SetDebugNameD3D11 (m_IB, Format("IndexBufferDynamic-%d", m_IBSize)); + } + // lock it if we have IB created successfully + if( m_IB ) + { + if( m_IBUsedBytes + ibCapacity > m_IBSize ) + { + D3D11_MAPPED_SUBRESOURCE mapped; + hr = ctx->Map (m_IB, 0, D3D11_MAP_WRITE_DISCARD, 0, &mapped); + if (FAILED(hr)) + { + printf_console ("d3d11: failed to lock dynamic index buffer with discard [%x]\n", hr); + *outIB = NULL; + success = false; + if (m_VB) + ctx->Unmap (m_VB, 0); + } + *outIB = mapped.pData; + m_IBUsedBytes = 0; + } else { + D3D11_MAPPED_SUBRESOURCE mapped; + hr = ctx->Map (m_IB, 0, D3D11_MAP_WRITE_NO_OVERWRITE, 0, &mapped); + if (FAILED(hr)) + { + printf_console ("d3d11: failed to lock dynamic index buffer, offset %i size %i [%x]\n", m_IBUsedBytes, ibCapacity, hr); + *outIB = NULL; + success = false; + if (m_VB) + ctx->Unmap (m_VB, 0); + } + *outIB = ((UInt8*)mapped.pData) + m_IBUsedBytes; + } + m_LastChunkStartIndex = m_IBUsedBytes / 2; + } + else + { + *outIB = NULL; + success = false; + } + } + + if( !success ) + m_LendedChunk = false; + + return success; +} + +void DynamicD3D11VBO::ReleaseChunk( UInt32 actualVertices, UInt32 actualIndices ) +{ + Assert( m_LendedChunk ); + Assert( m_LastRenderMode == kDrawIndexedTriangleStrip || m_LastRenderMode == kDrawIndexedQuads || m_LastRenderMode == kDrawIndexedPoints || m_LastRenderMode == kDrawIndexedLines || actualIndices % 3 == 0 ); + m_LendedChunk = false; + + const bool indexed = (m_LastRenderMode != kDrawQuads) && (m_LastRenderMode != kDrawTriangleStrip); + + m_LastChunkVertices = actualVertices; + m_LastChunkIndices = actualIndices; + + // unlock buffers + ID3D11DeviceContext* ctx = GetD3D11Context(); + ctx->Unmap (m_VB, 0); + if (indexed) + ctx->Unmap (m_IB, 0); + + if( !actualVertices || (indexed && !actualIndices) ) { + m_LastChunkShaderChannelMask = 0; + return; + } + + UInt32 actualVBSize = actualVertices * m_LastChunkStride; + m_VBUsedBytes += actualVBSize; + UInt32 actualIBSize = actualIndices * kVBOIndexSize; + m_IBUsedBytes += actualIBSize; +} + + |