AutomataSpeedrunMod/FactoryWrapper.cpp at mainline · DisrespectDwardo/AutomataSpeedrunMod · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
#include "FactoryWrapper.hpp"
#include "SwapChainWrapper.hpp"
#include "Log.hpp"
#include <cmath>
#include <random>

namespace DxWrappers {

DXGIFactoryWrapper::DXGIFactoryWrapper(CComPtr<IDXGIFactory2> target) {
    m_refCount = 1;
    m_target = target;

    D2D1_FACTORY_OPTIONS opt = { D2D1_DEBUG_LEVEL_ERROR };
    D2D1CreateFactory(D2D1_FACTORY_TYPE_SINGLE_THREADED, __uuidof(ID2D1Factory2), &opt, (void**)&m_D2DFactory);
}

DXGIFactoryWrapper::~DXGIFactoryWrapper() {}

void DXGIFactoryWrapper::toggleDvdMode(bool enabled) {
    if (m_currentSwapChain)
        m_currentSwapChain->toggleDvdMode(enabled);
}

HRESULT __stdcall DXGIFactoryWrapper::QueryInterface(REFIID riid, void** ppvObject) {
    if (riid == __uuidof(IDXGIFactory2) || riid == __uuidof(IDXGIFactory1) ||
        riid == __uuidof(IDXGIFactory) || riid == __uuidof(IDXGIObject) || riid == __uuidof(IUnknown)) {
        this->AddRef();
        *ppvObject = this;
        return S_OK;
    }

    *ppvObject = nullptr;
    return E_NOINTERFACE;
}

ULONG __stdcall DXGIFactoryWrapper::AddRef() {
    ++m_refCount;
    return m_refCount;
}

ULONG __stdcall DXGIFactoryWrapper::Release() {
    if (m_refCount > 0) {
        --m_refCount;
    }

    if (m_refCount == 0) {
        m_D2DFactory = nullptr;
        m_currentSwapChain = nullptr;
    }

    return m_refCount;
}

HRESULT __stdcall DXGIFactoryWrapper::CreateSwapChainForHwnd(IUnknown* pDevice, HWND hWnd, const DXGI_SWAP_CHAIN_DESC1* pDesc, const DXGI_SWAP_CHAIN_FULLSCREEN_DESC* pFullscreenDesc, IDXGIOutput* pRestrictToOutput, IDXGISwapChain1** ppSwapChain) {
    CComPtr<IDXGISwapChain1> swapChain;

    HRESULT result = m_target->CreateSwapChainForHwnd(pDevice, hWnd, pDesc, pFullscreenDesc, pRestrictToOutput, &swapChain);
    if (SUCCEEDED(result)) {
        m_currentSwapChain = new DXGISwapChainWrapper(pDevice, swapChain, m_D2DFactory);
        *ppSwapChain = m_currentSwapChain;
        return result;
    }

    *ppSwapChain = nullptr;
    return result;
}

HRESULT __stdcall DXGIFactoryWrapper::SetPrivateData(REFGUID Name, UINT DataSize, const void* pData) {
    return m_target->SetPrivateData(Name, DataSize, pData);
}

HRESULT __stdcall DXGIFactoryWrapper::SetPrivateDataInterface(REFGUID Name, const IUnknown* pUnknown) {
    return m_target->SetPrivateDataInterface(Name, pUnknown);
}

HRESULT __stdcall DXGIFactoryWrapper::GetPrivateData(REFGUID Name, UINT* pDataSize, void* pData) {
    return m_target->GetPrivateData(Name, pDataSize, pData);
}

HRESULT __stdcall DXGIFactoryWrapper::GetParent(REFIID riid, void** ppParent) {
    return m_target->GetParent(riid, ppParent);
}

HRESULT __stdcall DXGIFactoryWrapper::EnumAdapters(UINT Adapter, IDXGIAdapter** ppAdapter) {
    return m_target->EnumAdapters(Adapter, ppAdapter);
}

HRESULT __stdcall DXGIFactoryWrapper::MakeWindowAssociation(HWND WindowHandle, UINT Flags) {
    return m_target->MakeWindowAssociation(WindowHandle, Flags);
}

HRESULT __stdcall DXGIFactoryWrapper::GetWindowAssociation(HWND* pWindowHandle) {
    return m_target->GetWindowAssociation(pWindowHandle);
}

HRESULT __stdcall DXGIFactoryWrapper::CreateSwapChain(IUnknown* pDevice, DXGI_SWAP_CHAIN_DESC* pDesc, IDXGISwapChain** ppSwapChain) {
    return m_target->CreateSwapChain(pDevice, pDesc, ppSwapChain);
}

HRESULT __stdcall DXGIFactoryWrapper::CreateSoftwareAdapter(HMODULE Module, IDXGIAdapter** ppAdapter) {
    return m_target->CreateSoftwareAdapter(Module, ppAdapter);
}

HRESULT __stdcall DXGIFactoryWrapper::EnumAdapters1(UINT Adapter, IDXGIAdapter1** ppAdapter) {
    return m_target->EnumAdapters1(Adapter, ppAdapter);
}

BOOL __stdcall DXGIFactoryWrapper::IsCurrent() {
    return m_target->IsCurrent();
}

BOOL __stdcall DXGIFactoryWrapper::IsWindowedStereoEnabled() {
    return m_target->IsWindowedStereoEnabled();
}

HRESULT __stdcall DXGIFactoryWrapper::CreateSwapChainForCoreWindow(IUnknown* pDevice, IUnknown* pWindow, const DXGI_SWAP_CHAIN_DESC1* pDesc, IDXGIOutput* pRestrictToOutput, IDXGISwapChain1** ppSwapChain) {
    return m_target->CreateSwapChainForCoreWindow(pDevice, pWindow, pDesc, pRestrictToOutput, ppSwapChain);
}

HRESULT __stdcall DXGIFactoryWrapper::GetSharedResourceAdapterLuid(HANDLE hResource, LUID* pLuid) {
    return m_target->GetSharedResourceAdapterLuid(hResource, pLuid);
}

HRESULT __stdcall DXGIFactoryWrapper::RegisterStereoStatusWindow(HWND WindowHandle, UINT wMsg, DWORD* pdwCookie) {
    return m_target->RegisterStereoStatusWindow(WindowHandle, wMsg, pdwCookie);
}

HRESULT __stdcall DXGIFactoryWrapper::RegisterStereoStatusEvent(HANDLE hEvent, DWORD* pdwCookie) {
    return m_target->RegisterStereoStatusEvent(hEvent, pdwCookie);
}

void __stdcall DXGIFactoryWrapper::UnregisterStereoStatus(DWORD dwCookie) {
    m_target->UnregisterStereoStatus(dwCookie);
}

HRESULT __stdcall DXGIFactoryWrapper::RegisterOcclusionStatusWindow(HWND WindowHandle, UINT wMsg, DWORD* pdwCookie) {
    return m_target->RegisterOcclusionStatusWindow(WindowHandle, wMsg, pdwCookie);
}

HRESULT __stdcall DXGIFactoryWrapper::RegisterOcclusionStatusEvent(HANDLE hEvent, DWORD* pdwCookie) {
    return m_target->RegisterOcclusionStatusEvent(hEvent, pdwCookie);
}

void __stdcall DXGIFactoryWrapper::UnregisterOcclusionStatus(DWORD dwCookie) {
    m_target->UnregisterOcclusionStatus(dwCookie);
}

HRESULT __stdcall DXGIFactoryWrapper::CreateSwapChainForComposition(IUnknown* pDevice, const DXGI_SWAP_CHAIN_DESC1* pDesc, IDXGIOutput* pRestrictToOutput, IDXGISwapChain1** ppSwapChain) {
    return m_target->CreateSwapChainForComposition(pDevice, pDesc, pRestrictToOutput, ppSwapChain);
}

} // namespace DxWrappers