blob: 2e09dd82cb72a03a177b0c3f92ef8fd7e1a2e64d (
plain)
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
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
|
// Copyright 2008 Dolphin Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#include "VideoBackends/D3D/VideoBackend.h"
#include <memory>
#include <string>
#include "Common/Common.h"
#include "Common/CommonTypes.h"
#include "Common/MsgHandler.h"
#include "Common/StringUtil.h"
#include "VideoBackends/D3D/D3DBase.h"
#include "VideoBackends/D3D/D3DBoundingBox.h"
#include "VideoBackends/D3D/D3DGfx.h"
#include "VideoBackends/D3D/D3DPerfQuery.h"
#include "VideoBackends/D3D/D3DSwapChain.h"
#include "VideoBackends/D3D/D3DVertexManager.h"
#include "VideoBackends/D3DCommon/D3DCommon.h"
#include "VideoCommon/AbstractGfx.h"
#include "VideoCommon/FramebufferManager.h"
#include "VideoCommon/ShaderCache.h"
#include "VideoCommon/TextureCacheBase.h"
#include "VideoCommon/VideoCommon.h"
#include "VideoCommon/VideoConfig.h"
namespace DX11
{
std::string VideoBackend::GetConfigName() const
{
return CONFIG_NAME;
}
std::string VideoBackend::GetDisplayName() const
{
return _trans("Direct3D 11");
}
std::optional<std::string> VideoBackend::GetWarningMessage() const
{
std::optional<std::string> result;
// If relevant, show a warning about partial DX11.1 support
// This is being called BEFORE FillBackendInfo is called for this backend,
// so query for logic op support manually
bool supportsLogicOp = false;
if (D3DCommon::LoadLibraries())
{
supportsLogicOp = D3D::SupportsLogicOp(g_Config.iAdapter);
D3DCommon::UnloadLibraries();
}
if (!supportsLogicOp)
{
result = _trans("The Direct3D 11 renderer requires support for features not supported by your "
"system configuration. You may still use this backend, but you will encounter "
"graphical artifacts in certain games.\n"
"\n"
"Do you really want to switch to Direct3D 11? If unsure, select 'No'.");
}
return result;
}
void VideoBackend::InitBackendInfo(const WindowSystemInfo& wsi)
{
if (!D3DCommon::LoadLibraries())
return;
FillBackendInfo();
D3DCommon::UnloadLibraries();
}
void VideoBackend::FillBackendInfo()
{
g_backend_info.api_type = APIType::D3D;
g_backend_info.MaxTextureSize = D3D11_REQ_TEXTURE2D_U_OR_V_DIMENSION;
g_backend_info.bUsesLowerLeftOrigin = false;
g_backend_info.bSupportsExclusiveFullscreen = true;
g_backend_info.bSupportsDualSourceBlend = true;
g_backend_info.bSupportsPrimitiveRestart = true;
g_backend_info.bSupportsGeometryShaders = true;
g_backend_info.bSupportsComputeShaders = false;
g_backend_info.bSupports3DVision = true;
g_backend_info.bSupportsPostProcessing = true;
g_backend_info.bSupportsPaletteConversion = true;
g_backend_info.bSupportsClipControl = true;
g_backend_info.bSupportsDepthClamp = true;
g_backend_info.bSupportsReversedDepthRange = false;
g_backend_info.bSupportsMultithreading = false;
g_backend_info.bSupportsGPUTextureDecoding = true;
g_backend_info.bSupportsCopyToVram = true;
g_backend_info.bSupportsLargePoints = false;
g_backend_info.bSupportsDepthReadback = true;
g_backend_info.bSupportsPartialDepthCopies = false;
g_backend_info.bSupportsBitfield = false;
g_backend_info.bSupportsDynamicSamplerIndexing = false;
g_backend_info.bSupportsFramebufferFetch = false;
g_backend_info.bSupportsBackgroundCompiling = true;
g_backend_info.bSupportsST3CTextures = true;
g_backend_info.bSupportsBPTCTextures = true;
g_backend_info.bSupportsEarlyZ = true;
g_backend_info.bSupportsBBox = true;
g_backend_info.bSupportsFragmentStoresAndAtomics = true;
g_backend_info.bSupportsGSInstancing = true;
g_backend_info.bSupportsSSAA = true;
g_backend_info.bSupportsShaderBinaries = true;
g_backend_info.bSupportsPipelineCacheData = false;
g_backend_info.bSupportsCoarseDerivatives = true;
g_backend_info.bSupportsTextureQueryLevels = true;
g_backend_info.bSupportsLodBiasInSampler = true;
g_backend_info.bSupportsLogicOp = D3D::SupportsLogicOp(g_Config.iAdapter);
g_backend_info.bSupportsSettingObjectNames = true;
g_backend_info.bSupportsPartialMultisampleResolve = true;
g_backend_info.bSupportsDynamicVertexLoader = false;
g_backend_info.bSupportsHDROutput = true;
g_backend_info.Adapters = D3DCommon::GetAdapterNames();
g_backend_info.AAModes = D3D::GetAAModes(g_Config.iAdapter);
// Override optional features if we are actually booting.
if (D3D::device)
{
g_backend_info.bSupportsST3CTextures = D3D::SupportsTextureFormat(DXGI_FORMAT_BC1_UNORM) &&
D3D::SupportsTextureFormat(DXGI_FORMAT_BC2_UNORM) &&
D3D::SupportsTextureFormat(DXGI_FORMAT_BC3_UNORM);
g_backend_info.bSupportsBPTCTextures = D3D::SupportsTextureFormat(DXGI_FORMAT_BC7_UNORM);
// Features only supported with a FL11.0+ device.
const bool shader_model_5_supported = D3D::feature_level >= D3D_FEATURE_LEVEL_11_0;
g_backend_info.bSupportsEarlyZ = shader_model_5_supported;
g_backend_info.bSupportsBBox = shader_model_5_supported;
g_backend_info.bSupportsFragmentStoresAndAtomics = shader_model_5_supported;
g_backend_info.bSupportsGSInstancing = shader_model_5_supported;
g_backend_info.bSupportsSSAA = shader_model_5_supported;
g_backend_info.bSupportsGPUTextureDecoding = shader_model_5_supported;
}
}
bool VideoBackend::Initialize(const WindowSystemInfo& wsi)
{
if (!D3D::Create(g_Config.iAdapter, g_Config.bEnableValidationLayer))
return false;
FillBackendInfo();
UpdateActiveConfig();
std::unique_ptr<SwapChain> swap_chain;
if (wsi.render_surface && !(swap_chain = SwapChain::Create(wsi)))
{
PanicAlertFmtT("Failed to create D3D swap chain");
ShutdownShared();
D3D::Destroy();
return false;
}
auto gfx = std::make_unique<DX11::Gfx>(std::move(swap_chain), wsi.render_surface_scale);
auto vertex_manager = std::make_unique<VertexManager>();
auto perf_query = std::make_unique<PerfQuery>();
auto bounding_box = std::make_unique<D3DBoundingBox>();
return InitializeShared(std::move(gfx), std::move(vertex_manager), std::move(perf_query),
std::move(bounding_box));
}
void VideoBackend::Shutdown()
{
ShutdownShared();
D3D::Destroy();
}
} // namespace DX11
|
