From bff7253ecdcbbaeb07549f33954b9cc4e20f0ffd Mon Sep 17 00:00:00 2001 From: narzoul Date: Tue, 26 May 2020 00:28:17 +0200 Subject: [PATCH] Improved rendering performance for indexed and system memory primitives --- DDrawCompat/D3dDdi/Device.cpp | 80 ++---- DDrawCompat/D3dDdi/Device.h | 11 +- DDrawCompat/D3dDdi/DeviceFuncs.cpp | 12 +- DDrawCompat/D3dDdi/DrawPrimitive.cpp | 329 ++++++++++++++++++++++++ DDrawCompat/D3dDdi/DrawPrimitive.h | 74 ++++++ DDrawCompat/D3dDdi/Resource.cpp | 34 --- DDrawCompat/D3dDdi/Resource.h | 3 +- DDrawCompat/DDrawCompat.vcxproj | 2 + DDrawCompat/DDrawCompat.vcxproj.filters | 6 + 9 files changed, 439 insertions(+), 112 deletions(-) create mode 100644 DDrawCompat/D3dDdi/DrawPrimitive.cpp create mode 100644 DDrawCompat/D3dDdi/DrawPrimitive.h diff --git a/DDrawCompat/D3dDdi/Device.cpp b/DDrawCompat/D3dDdi/Device.cpp index f83fbaf..86e1c19 100644 --- a/DDrawCompat/D3dDdi/Device.cpp +++ b/DDrawCompat/D3dDdi/Device.cpp @@ -2,11 +2,11 @@ #include #include <../km/d3dkmthk.h> -#include "Common/HResultException.h" -#include "D3dDdi/Adapter.h" -#include "D3dDdi/Device.h" -#include "D3dDdi/DeviceFuncs.h" -#include "D3dDdi/Resource.h" +#include +#include +#include +#include +#include namespace { @@ -24,8 +24,7 @@ namespace D3dDdi , m_renderTarget(nullptr) , m_renderTargetSubResourceIndex(0) , m_sharedPrimary(nullptr) - , m_streamSourceData{} - , m_streamSource(nullptr) + , m_drawPrimitive(*this) { } @@ -66,6 +65,13 @@ namespace D3dDdi { Resource resource(*this, data); m_resources.emplace(resource, std::move(resource)); + if (data.Flags.VertexBuffer && + D3DDDIPOOL_SYSTEMMEM == data.Pool && + data.pSurfList[0].pSysMem) + { + m_drawPrimitive.addSysMemVertexBuffer(data.hResource, + static_cast(const_cast(data.pSurfList[0].pSysMem)), data.Fvf); + } return S_OK; } catch (const HResultException& e) @@ -115,57 +121,27 @@ namespace D3dDdi g_gdiResourceHandle = nullptr; g_gdiResource = nullptr; } - if (resource == m_streamSource) - { - m_streamSource = nullptr; - } + m_drawPrimitive.removeSysMemVertexBuffer(resource); } return result; } - HRESULT Device::drawIndexedPrimitive(const D3DDDIARG_DRAWINDEXEDPRIMITIVE* data) - { - prepareForRendering(); - return m_origVtable.pfnDrawIndexedPrimitive(m_device, data); - } - HRESULT Device::drawIndexedPrimitive2(const D3DDDIARG_DRAWINDEXEDPRIMITIVE2* data, UINT indicesSize, const void* indexBuffer, const UINT* flagBuffer) { + if (2 != indicesSize) + { + return E_INVALIDARG; + } prepareForRendering(); - return m_origVtable.pfnDrawIndexedPrimitive2(m_device, data, indicesSize, indexBuffer, flagBuffer); + return m_drawPrimitive.drawIndexed(*data, indexBuffer, flagBuffer); } HRESULT Device::drawPrimitive(const D3DDDIARG_DRAWPRIMITIVE* data, const UINT* flagBuffer) { - if (m_streamSource && 0 != m_streamSourceData.Stride) - { - m_streamSource->fixVertexData(m_streamSourceData.Offset + data->VStart * m_streamSourceData.Stride, - data->PrimitiveCount, m_streamSourceData.Stride); - } prepareForRendering(); - return m_origVtable.pfnDrawPrimitive(m_device, data, flagBuffer); - } - - HRESULT Device::drawPrimitive2(const D3DDDIARG_DRAWPRIMITIVE2* data) - { - prepareForRendering(); - return m_origVtable.pfnDrawPrimitive2(m_device, data); - } - - HRESULT Device::drawRectPatch(const D3DDDIARG_DRAWRECTPATCH* data, const D3DDDIRECTPATCH_INFO* info, - const FLOAT* patch) - { - prepareForRendering(); - return m_origVtable.pfnDrawRectPatch(m_device, data, info, patch); - } - - HRESULT Device::drawTriPatch(const D3DDDIARG_DRAWTRIPATCH* data, const D3DDDITRIPATCH_INFO* info, - const FLOAT* patch) - { - prepareForRendering(); - return m_origVtable.pfnDrawTriPatch(m_device, data, info, patch); + return m_drawPrimitive.draw(*data, flagBuffer); } HRESULT Device::flush() @@ -234,24 +210,12 @@ namespace D3dDdi HRESULT Device::setStreamSource(const D3DDDIARG_SETSTREAMSOURCE* data) { - HRESULT result = m_origVtable.pfnSetStreamSource(m_device, data); - if (SUCCEEDED(result) && 0 == data->Stream) - { - m_streamSourceData = *data; - m_streamSource = getResource(data->hVertexBuffer); - } - return result; + return m_drawPrimitive.setStreamSource(*data); } HRESULT Device::setStreamSourceUm(const D3DDDIARG_SETSTREAMSOURCEUM* data, const void* umBuffer) { - HRESULT result = m_origVtable.pfnSetStreamSourceUm(m_device, data, umBuffer); - if (SUCCEEDED(result) && 0 == data->Stream) - { - m_streamSourceData = {}; - m_streamSource = nullptr; - } - return result; + return m_drawPrimitive.setStreamSourceUm(*data, umBuffer); } HRESULT Device::unlock(const D3DDDIARG_UNLOCK* data) diff --git a/DDrawCompat/D3dDdi/Device.h b/DDrawCompat/D3dDdi/Device.h index 2c782af..aa4a479 100644 --- a/DDrawCompat/D3dDdi/Device.h +++ b/DDrawCompat/D3dDdi/Device.h @@ -7,6 +7,8 @@ #include #include +#include + namespace D3dDdi { class Adapter; @@ -23,15 +25,9 @@ namespace D3dDdi HRESULT createResource(D3DDDIARG_CREATERESOURCE* data); HRESULT createResource2(D3DDDIARG_CREATERESOURCE2* data); HRESULT destroyResource(HANDLE resource); - HRESULT drawIndexedPrimitive(const D3DDDIARG_DRAWINDEXEDPRIMITIVE* data); HRESULT drawIndexedPrimitive2(const D3DDDIARG_DRAWINDEXEDPRIMITIVE2* data, UINT indicesSize, const void* indexBuffer, const UINT* flagBuffer); HRESULT drawPrimitive(const D3DDDIARG_DRAWPRIMITIVE* data, const UINT* flagBuffer); - HRESULT drawPrimitive2(const D3DDDIARG_DRAWPRIMITIVE2* data); - HRESULT drawRectPatch(const D3DDDIARG_DRAWRECTPATCH* data, const D3DDDIRECTPATCH_INFO* info, - const FLOAT* patch); - HRESULT drawTriPatch(const D3DDDIARG_DRAWTRIPATCH* data, const D3DDDITRIPATCH_INFO* info, - const FLOAT* patch); HRESULT flush(); HRESULT flush1(UINT FlushFlags); HRESULT lock(D3DDDIARG_LOCK* data); @@ -74,8 +70,7 @@ namespace D3dDdi Resource* m_renderTarget; UINT m_renderTargetSubResourceIndex; HANDLE m_sharedPrimary; - D3DDDIARG_SETSTREAMSOURCE m_streamSourceData; - Resource* m_streamSource; + DrawPrimitive m_drawPrimitive; static std::map s_devices; static bool s_isFlushEnabled; diff --git a/DDrawCompat/D3dDdi/DeviceFuncs.cpp b/DDrawCompat/D3dDdi/DeviceFuncs.cpp index 60f9867..423189a 100644 --- a/DDrawCompat/D3dDdi/DeviceFuncs.cpp +++ b/DDrawCompat/D3dDdi/DeviceFuncs.cpp @@ -11,12 +11,8 @@ namespace HRESULT APIENTRY destroyDevice(HANDLE hDevice) { - HRESULT result = D3dDdi::DeviceFuncs::s_origVtablePtr->pfnDestroyDevice(hDevice); - if (SUCCEEDED(result)) - { - D3dDdi::Device::remove(hDevice); - } - return result; + D3dDdi::Device::remove(hDevice); + return D3dDdi::DeviceFuncs::s_origVtablePtr->pfnDestroyDevice(hDevice); } } @@ -38,12 +34,8 @@ namespace D3dDdi vtable.pfnCreateResource2 = &DEVICE_FUNC(createResource2); vtable.pfnDestroyDevice = &destroyDevice; vtable.pfnDestroyResource = &DEVICE_FUNC(destroyResource); - vtable.pfnDrawIndexedPrimitive = &DEVICE_FUNC(drawIndexedPrimitive); vtable.pfnDrawIndexedPrimitive2 = &DEVICE_FUNC(drawIndexedPrimitive2); vtable.pfnDrawPrimitive = &DEVICE_FUNC(drawPrimitive); - vtable.pfnDrawPrimitive2 = &DEVICE_FUNC(drawPrimitive2); - vtable.pfnDrawRectPatch = &DEVICE_FUNC(drawRectPatch); - vtable.pfnDrawTriPatch = &DEVICE_FUNC(drawTriPatch); vtable.pfnFlush = &DEVICE_FUNC(flush); vtable.pfnFlush1 = &DEVICE_FUNC(flush1); vtable.pfnLock = &DEVICE_FUNC(lock); diff --git a/DDrawCompat/D3dDdi/DrawPrimitive.cpp b/DDrawCompat/D3dDdi/DrawPrimitive.cpp new file mode 100644 index 0000000..c3f0344 --- /dev/null +++ b/DDrawCompat/D3dDdi/DrawPrimitive.cpp @@ -0,0 +1,329 @@ +#include +#include + +#include +#include +#include +#include + +namespace +{ + class VertexRhwFixer + { + public: + VertexRhwFixer(D3DTLVERTEX* vertex) + { + if (vertex && 0.0f == vertex->rhw) + { + vertex->rhw = 1.0f; + m_vertex = vertex; + } + else + { + m_vertex = nullptr; + } + } + + VertexRhwFixer(void* vertex) + : VertexRhwFixer(static_cast(vertex)) + { + } + + ~VertexRhwFixer() + { + if (m_vertex) + { + m_vertex->rhw = 0.0f; + } + } + + private: + D3DTLVERTEX* m_vertex; + }; + + UINT getVertexCount(D3DPRIMITIVETYPE primitiveType, UINT primitiveCount) + { + switch (primitiveType) + { + case D3DPT_POINTLIST: + return primitiveCount; + case D3DPT_LINELIST: + return primitiveCount * 2; + case D3DPT_LINESTRIP: + return primitiveCount + 1; + case D3DPT_TRIANGLELIST: + return primitiveCount * 3; + case D3DPT_TRIANGLESTRIP: + case D3DPT_TRIANGLEFAN: + return primitiveCount + 2; + } + return 0; + } + + UINT roundUpToNearestMultiple(UINT num, UINT mul) + { + return (num + mul - 1) / mul * mul; + } +} + +namespace D3dDdi +{ + DrawPrimitive::Buffer::Buffer(HANDLE device, const D3DDDI_DEVICEFUNCS& origVtable, D3DDDIFORMAT format, UINT size) + : m_device(device) + , m_origVtable(origVtable) + , m_resource(nullptr, [=](HANDLE vb) { origVtable.pfnDestroyResource(device, vb); }) + , m_format(format) + , m_initialSize(size) + , m_size(0) + , m_stride(0) + , m_pos(0) + { + resize(size); + } + + HANDLE DrawPrimitive::Buffer::getHandle() const + { + return m_resource.get(); + } + + void* DrawPrimitive::Buffer::lock(UINT size) + { + D3DDDIARG_LOCK lock = {}; + lock.hResource = m_resource.get(); + lock.Range.Offset = m_pos; + lock.Range.Size = size; + lock.Flags.RangeValid = 1; + + if (0 == m_pos) + { + lock.Flags.Discard = 1; + } + else + { + lock.Flags.WriteOnly = 1; + lock.Flags.NoOverwrite = 1; + } + + m_origVtable.pfnLock(m_device, &lock); + return lock.pSurfData; + } + + UINT DrawPrimitive::Buffer::load(const void* src, UINT count, UINT stride) + { + if (stride != m_stride) + { + m_stride = stride; + m_pos = roundUpToNearestMultiple(m_pos, stride); + } + + UINT size = count * m_stride; + if (m_pos + size > m_size) + { + m_pos = 0; + if (size > m_size) + { + if (!resize(roundUpToNearestMultiple(size, m_initialSize))) + { + return UINT_MAX; + } + } + } + + auto dst = lock(size); + if (!dst) + { + return UINT_MAX; + } + + memcpy(dst, src, size); + unlock(); + + UINT pos = m_pos; + m_pos += size; + return pos; + } + + bool DrawPrimitive::Buffer::resize(UINT size) + { + if (0 == size) + { + m_resource.reset(); + m_size = 0; + return true; + } + + D3DDDI_SURFACEINFO surfaceInfo = {}; + surfaceInfo.Width = size; + surfaceInfo.Height = 1; + + D3DDDIARG_CREATERESOURCE2 cr = {}; + cr.Format = m_format; + cr.Pool = D3DDDIPOOL_VIDEOMEMORY; + cr.pSurfList = &surfaceInfo; + cr.SurfCount = 1; + cr.Flags.Dynamic = 1; + cr.Flags.WriteOnly = 1; + if (D3DDDIFMT_VERTEXDATA == m_format) + { + cr.Flags.VertexBuffer = 1; + } + else + { + cr.Flags.IndexBuffer = 1; + } + + if (FAILED(m_origVtable.pfnCreateResource2 + ? m_origVtable.pfnCreateResource2(m_device, &cr) + : m_origVtable.pfnCreateResource(m_device, reinterpret_cast(&cr)))) + { + return false; + } + + m_resource.reset(cr.hResource); + m_size = size; + return true; + } + + void DrawPrimitive::Buffer::unlock() + { + D3DDDIARG_UNLOCK unlock = {}; + unlock.hResource = m_resource.get(); + m_origVtable.pfnUnlock(m_device, &unlock); + } + + DrawPrimitive::DrawPrimitive(Device& device) + : m_device(device) + , m_origVtable(device.getOrigVtable()) + , m_vertexBuffer(m_device, m_origVtable, D3DDDIFMT_VERTEXDATA, 1024 * 1024) + , m_indexBuffer(m_device, m_origVtable, D3DDDIFMT_INDEX16, 256 * 1024) + , m_streamSource{} + { + if (m_indexBuffer.getHandle()) + { + D3DDDIARG_SETINDICES si = {}; + si.hIndexBuffer = m_indexBuffer.getHandle(); + si.Stride = 2; + m_origVtable.pfnSetIndices(m_device, &si); + } + } + + void DrawPrimitive::addSysMemVertexBuffer(HANDLE resource, BYTE* vertices, UINT fvf) + { + m_sysMemVertexBuffers[resource] = { vertices, fvf }; + } + + HRESULT DrawPrimitive::draw(const D3DDDIARG_DRAWPRIMITIVE& data, const UINT* flagBuffer) + { + auto firstVertexPtr = m_streamSource.vertices + data.VStart * m_streamSource.stride; + VertexRhwFixer fixer((m_streamSource.fvf & D3DFVF_XYZRHW) ? firstVertexPtr : nullptr); + + if (m_streamSource.vertices && m_vertexBuffer.getHandle()) + { + auto vertexCount = getVertexCount(data.PrimitiveType, data.PrimitiveCount); + auto vbOffset = m_vertexBuffer.load(firstVertexPtr, vertexCount, m_streamSource.stride); + if (UINT_MAX == vbOffset) + { + return E_OUTOFMEMORY; + } + + D3DDDIARG_DRAWPRIMITIVE dp = data; + dp.VStart = vbOffset / m_streamSource.stride; + return m_origVtable.pfnDrawPrimitive(m_device, &dp, flagBuffer); + } + + return m_origVtable.pfnDrawPrimitive(m_device, &data, flagBuffer); + } + + HRESULT DrawPrimitive::drawIndexed( + D3DDDIARG_DRAWINDEXEDPRIMITIVE2 data, const void* indices, const UINT* flagBuffer) + { + auto firstIndexPtr = reinterpret_cast(static_cast(indices) + data.StartIndexOffset); + auto indexCount = getVertexCount(data.PrimitiveType, data.PrimitiveCount); + auto [min, max] = std::minmax_element(firstIndexPtr, firstIndexPtr + indexCount); + data.MinIndex = *min; + data.NumVertices = *max - *min + 1; + + auto firstVertexPtr = m_streamSource.vertices + data.BaseVertexOffset + data.MinIndex * m_streamSource.stride; + VertexRhwFixer fixer((m_streamSource.fvf & D3DFVF_XYZRHW) ? firstVertexPtr : nullptr); + + if (m_streamSource.vertices && m_vertexBuffer.getHandle()) + { + data.BaseVertexOffset = m_vertexBuffer.load(firstVertexPtr, data.NumVertices, m_streamSource.stride); + if (UINT_MAX == data.BaseVertexOffset) + { + return E_OUTOFMEMORY; + } + data.BaseVertexOffset -= data.MinIndex * m_streamSource.stride; + } + + if (m_indexBuffer.getHandle() && !flagBuffer) + { + D3DDDIARG_DRAWINDEXEDPRIMITIVE dp = {}; + dp.PrimitiveType = data.PrimitiveType; + dp.BaseVertexIndex = data.BaseVertexOffset / m_streamSource.stride; + dp.MinIndex = data.MinIndex; + dp.NumVertices = data.NumVertices; + dp.StartIndex = m_indexBuffer.load(firstIndexPtr, indexCount, 2) / 2; + dp.PrimitiveCount = data.PrimitiveCount; + return m_origVtable.pfnDrawIndexedPrimitive(m_device, &dp); + } + + return m_origVtable.pfnDrawIndexedPrimitive2(m_device, &data, 2, indices, flagBuffer); + } + + void DrawPrimitive::removeSysMemVertexBuffer(HANDLE resource) + { + m_sysMemVertexBuffers.erase(resource); + } + + HRESULT DrawPrimitive::setStreamSource(BYTE* vertices, UINT stride, UINT fvf) + { + HRESULT result = S_OK; + if (m_vertexBuffer.getHandle()) + { + if (!m_streamSource.vertices || stride != m_streamSource.stride) + { + D3DDDIARG_SETSTREAMSOURCE ss = {}; + ss.hVertexBuffer = m_vertexBuffer.getHandle(); + ss.Stride = stride; + result = m_origVtable.pfnSetStreamSource(m_device, &ss); + } + } + else if (vertices != m_streamSource.vertices || stride != m_streamSource.stride) + { + D3DDDIARG_SETSTREAMSOURCEUM ss = {}; + ss.Stride = stride; + result = m_origVtable.pfnSetStreamSourceUm(m_device, &ss, vertices); + } + + m_streamSource.vertices = vertices; + m_streamSource.stride = stride; + m_streamSource.fvf = fvf; + return result; + } + + HRESULT DrawPrimitive::setStreamSource(const D3DDDIARG_SETSTREAMSOURCE& data) + { + if (0 != data.Stride) + { + auto it = m_sysMemVertexBuffers.find(data.hVertexBuffer); + if (it != m_sysMemVertexBuffers.end()) + { + return setStreamSource(it->second.vertices + data.Offset, data.Stride, it->second.fvf); + } + } + + HRESULT result = m_origVtable.pfnSetStreamSource(m_device, &data); + if (SUCCEEDED(result)) + { + m_streamSource = {}; + m_streamSource.stride = data.Stride; + } + return result; + } + + HRESULT DrawPrimitive::setStreamSourceUm(const D3DDDIARG_SETSTREAMSOURCEUM& data, const void* umBuffer) + { + return setStreamSource(static_cast(const_cast(umBuffer)), data.Stride, 0); + } +} diff --git a/DDrawCompat/D3dDdi/DrawPrimitive.h b/DDrawCompat/D3dDdi/DrawPrimitive.h new file mode 100644 index 0000000..a589059 --- /dev/null +++ b/DDrawCompat/D3dDdi/DrawPrimitive.h @@ -0,0 +1,74 @@ +#pragma once + +#include +#include +#include +#include + +#include +#include + +namespace D3dDdi +{ + class Device; + + class DrawPrimitive + { + public: + DrawPrimitive(Device& device); + + void addSysMemVertexBuffer(HANDLE resource, BYTE* vertices, UINT fvf); + void removeSysMemVertexBuffer(HANDLE resource); + + HRESULT draw(const D3DDDIARG_DRAWPRIMITIVE& data, const UINT* flagBuffer); + HRESULT drawIndexed(D3DDDIARG_DRAWINDEXEDPRIMITIVE2 data, const void* indices, const UINT* flagBuffer); + HRESULT setStreamSource(const D3DDDIARG_SETSTREAMSOURCE& data); + HRESULT setStreamSourceUm(const D3DDDIARG_SETSTREAMSOURCEUM& data, const void* umBuffer); + + private: + class Buffer + { + public: + Buffer(HANDLE device, const D3DDDI_DEVICEFUNCS& origVtable, D3DDDIFORMAT format, UINT size); + + HANDLE getHandle() const; + UINT load(const void* src, UINT count, UINT stride); + + private: + void* lock(UINT size); + bool resize(UINT size); + void unlock(); + + HANDLE m_device = nullptr; + const D3DDDI_DEVICEFUNCS& m_origVtable; + std::unique_ptr> m_resource; + D3DDDIFORMAT m_format; + UINT m_initialSize; + UINT m_size; + UINT m_stride; + UINT m_pos; + }; + + struct StreamSource + { + BYTE* vertices; + UINT stride; + UINT fvf; + }; + + struct SysMemVertexBuffer + { + BYTE* vertices; + UINT fvf; + }; + + HRESULT setStreamSource(BYTE* vertices, UINT stride, UINT fvf); + + HANDLE m_device; + const D3DDDI_DEVICEFUNCS& m_origVtable; + Buffer m_vertexBuffer; + Buffer m_indexBuffer; + StreamSource m_streamSource; + std::map m_sysMemVertexBuffers; + }; +} diff --git a/DDrawCompat/D3dDdi/Resource.cpp b/DDrawCompat/D3dDdi/Resource.cpp index aba3a7a..3ff008a 100644 --- a/DDrawCompat/D3dDdi/Resource.cpp +++ b/DDrawCompat/D3dDdi/Resource.cpp @@ -143,15 +143,6 @@ namespace D3dDdi , m_lockBuffer(nullptr, &heapFree) , m_lockResource(nullptr, ResourceDeleter(device)) { - if (D3DDDIFMT_VERTEXDATA == data.Format && - data.Flags.VertexBuffer && - data.Flags.MightDrawFromLocked && - D3DDDIPOOL_SYSTEMMEM != data.Pool) - { - const HRESULT D3DERR_NOTAVAILABLE = 0x8876086A; - throw HResultException(D3DERR_NOTAVAILABLE); - } - fixResourceData(device, reinterpret_cast(m_fixedData)); m_formatInfo = getFormatInfo(m_fixedData.Format); @@ -477,31 +468,6 @@ namespace D3dDdi } } - void Resource::fixVertexData(UINT offset, UINT count, UINT stride) - { - if (!m_fixedData.Flags.MightDrawFromLocked || - !m_fixedData.pSurfList[0].pSysMem || - !(m_fixedData.Fvf & D3DFVF_XYZRHW)) - { - return; - } - - unsigned char* data = static_cast(const_cast(m_fixedData.pSurfList[0].pSysMem)) + offset; - if (0.0f != reinterpret_cast(data)->rhw) - { - return; - } - - for (UINT i = 0; i < count; ++i) - { - if (0.0f == reinterpret_cast(data)->rhw) - { - reinterpret_cast(data)->rhw = 1.0f; - } - data += stride; - } - } - void* Resource::getLockPtr(UINT subResourceIndex) { return m_lockData.empty() ? nullptr : m_lockData[subResourceIndex].data; diff --git a/DDrawCompat/D3dDdi/Resource.h b/DDrawCompat/D3dDdi/Resource.h index 667ef6f..c793f68 100644 --- a/DDrawCompat/D3dDdi/Resource.h +++ b/DDrawCompat/D3dDdi/Resource.h @@ -6,7 +6,7 @@ #include #include -#include "D3dDdi/FormatInfo.h" +#include namespace D3dDdi { @@ -30,7 +30,6 @@ namespace D3dDdi HRESULT blt(D3DDDIARG_BLT data); HRESULT colorFill(D3DDDIARG_COLORFILL data); void endGdiAccess(bool isReadOnly); - void fixVertexData(UINT offset, UINT count, UINT stride); void* getLockPtr(UINT subResourceIndex); HRESULT lock(D3DDDIARG_LOCK& data); void prepareForRendering(UINT subResourceIndex, bool isReadOnly); diff --git a/DDrawCompat/DDrawCompat.vcxproj b/DDrawCompat/DDrawCompat.vcxproj index 138e408..f166d58 100644 --- a/DDrawCompat/DDrawCompat.vcxproj +++ b/DDrawCompat/DDrawCompat.vcxproj @@ -154,6 +154,7 @@ + @@ -243,6 +244,7 @@ + diff --git a/DDrawCompat/DDrawCompat.vcxproj.filters b/DDrawCompat/DDrawCompat.vcxproj.filters index f345cf0..45ef71b 100644 --- a/DDrawCompat/DDrawCompat.vcxproj.filters +++ b/DDrawCompat/DDrawCompat.vcxproj.filters @@ -387,6 +387,9 @@ Header Files\D3dDdi\Log + + Header Files\D3dDdi + @@ -593,5 +596,8 @@ Source Files\D3dDdi\Log + + Source Files\D3dDdi + \ No newline at end of file