mirror of
https://github.com/Droid-Deck/DroidDeck.git
synced 2026-11-18 20:36:04 +00:00
215 lines
11 KiB
C++
215 lines
11 KiB
C++
// Backend/adapter fixture for the verbatim DXVK functions in d3d9_production.inc.
|
|
#include <algorithm>
|
|
#include <cassert>
|
|
#include <cstdint>
|
|
#include <memory>
|
|
#include <stdexcept>
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
using HRESULT = int32_t;
|
|
using DWORD = uint32_t;
|
|
using UINT = uint32_t;
|
|
using VkSampleCountFlagBits = uint32_t;
|
|
constexpr HRESULT D3D_OK = 0, D3DERR_INVALIDCALL = -1,
|
|
D3DERR_NOTAVAILABLE = -2, D3DERR_OUTOFVIDEOMEMORY = -3;
|
|
constexpr uint32_t VK_SAMPLE_COUNT_1_BIT = 1, VK_IMAGE_ASPECT_COLOR_BIT = 1;
|
|
constexpr bool FALSE = false, TRUE = true;
|
|
#define FAILED(x) ((x) < 0)
|
|
#define unlikely(x) (x)
|
|
enum D3DMULTISAMPLE_TYPE { D3DMULTISAMPLE_NONE, D3DMULTISAMPLE_NONMASKABLE,
|
|
D3DMULTISAMPLE_16_SAMPLES = 16 };
|
|
enum D3DRESOURCETYPE { D3DRTYPE_SURFACE, D3DRTYPE_CUBETEXTURE, D3DRTYPE_VOLUMETEXTURE };
|
|
enum D3DPOOL { D3DPOOL_DEFAULT, D3DPOOL_MANAGED, D3DPOOL_SYSTEMMEM, D3DPOOL_SCRATCH };
|
|
enum class D3DCompatibility { D3D9Ex };
|
|
enum class D3D9Format { X8R8G8B8, D24S8, A8, NULL_FORMAT, ATI2,
|
|
D32_LOCKABLE, D32F_LOCKABLE, D16_LOCKABLE, S8_LOCKABLE };
|
|
constexpr DWORD D3DUSAGE_RENDERTARGET = 1, D3DUSAGE_DEPTHSTENCIL = 2,
|
|
D3DUSAGE_DYNAMIC = 4, D3DUSAGE_WRITEONLY = 8, D3DUSAGE_AUTOGENMIPMAP = 16;
|
|
constexpr DWORD D3DPRESENTFLAG_LOCKABLE_BACKBUFFER = 1, D3DPRESENTFLAG_DISCARD_DEPTHSTENCIL = 2;
|
|
constexpr int D3DDEVTYPE_HAL = 1, VK_IMAGE_LAYOUT_UNDEFINED = 0;
|
|
struct Extent { uint32_t width, height, depth = 1; };
|
|
namespace util {
|
|
uint32_t computeMipLevelCount(Extent e) {
|
|
uint32_t n = std::max({e.width, e.height, e.depth}), levels = 0;
|
|
do { ++levels; n >>= 1; } while (n);
|
|
return levels;
|
|
}
|
|
}
|
|
bool IsPoolManaged(D3DPOOL pool) { return pool == D3DPOOL_MANAGED; }
|
|
bool IsDXTFormat(D3D9Format) { return false; }
|
|
bool IsDepthStencilFormat(D3D9Format format) { return format == D3D9Format::D24S8; }
|
|
bool IsLockableDepthStencilFormat(D3D9Format) { return false; }
|
|
struct D3D9_FORMAT_BLOCK_SIZE { uint32_t Width, Height; };
|
|
D3D9_FORMAT_BLOCK_SIZE GetFormatAlignedBlockSize(D3D9Format) { return {1, 1}; }
|
|
D3D9Format EnumerateFormat(D3D9Format format) { return format; }
|
|
struct D3D9_COMMON_TEXTURE_DESC {
|
|
uint32_t Width = 1280, Height = 720, Depth = 1, MipLevels = 1, ArraySize = 1;
|
|
D3D9Format Format = D3D9Format::X8R8G8B8;
|
|
D3DMULTISAMPLE_TYPE MultiSample = D3DMULTISAMPLE_NONE;
|
|
DWORD MultisampleQuality = 0;
|
|
D3DPOOL Pool = D3DPOOL_DEFAULT;
|
|
DWORD Usage = D3DUSAGE_RENDERTARGET;
|
|
bool Discard = false, IsBackBuffer = false, IsAttachmentOnly = false, IsLockable = false;
|
|
};
|
|
struct D3DPRESENT_PARAMETERS {
|
|
uint32_t BackBufferWidth = 1280, BackBufferHeight = 720;
|
|
D3D9Format BackBufferFormat = D3D9Format::X8R8G8B8;
|
|
D3DMULTISAMPLE_TYPE MultiSampleType = D3DMULTISAMPLE_TYPE(4);
|
|
DWORD MultiSampleQuality = 0, Flags = 0;
|
|
D3D9Format AutoDepthStencilFormat = D3D9Format::D24S8;
|
|
};
|
|
struct Options {
|
|
bool forceSingleSample = false, extraFrontbuffer = false,
|
|
disableA8RT = false, supportCubeDepthFormats = false;
|
|
};
|
|
struct FormatMapping {
|
|
uint32_t Aspect;
|
|
bool IsValid() const { return true; }
|
|
};
|
|
struct Adapter {
|
|
bool supported = true;
|
|
std::vector<D3DMULTISAMPLE_TYPE> checked;
|
|
HRESULT CheckDeviceMultiSampleType(int, D3D9Format, bool, D3DMULTISAMPLE_TYPE samples, void*) {
|
|
checked.push_back(samples);
|
|
return supported ? D3D_OK : D3DERR_NOTAVAILABLE;
|
|
}
|
|
};
|
|
struct ImageInfo { Extent extent; VkSampleCountFlagBits sampleCount; };
|
|
struct DxvkImage { ImageInfo info; };
|
|
template<typename T> using Rc = std::shared_ptr<T>;
|
|
template<typename T, unsigned N> using small_vector = std::vector<T>;
|
|
struct DxvkContext {
|
|
unsigned initialized = 0;
|
|
void initImage(const Rc<DxvkImage>&, int) { ++initialized; }
|
|
};
|
|
struct D3D9DeviceEx {
|
|
Options options;
|
|
Adapter adapter;
|
|
DxvkContext context;
|
|
unsigned attempts = 0, failAt = 0, losable = 0, live = 0, injected = 0;
|
|
std::vector<D3D9_COMMON_TEXTURE_DESC> created;
|
|
Options* GetOptions() { return &options; }
|
|
Adapter* GetAdapter() { return &adapter; }
|
|
FormatMapping LookupFormat(D3D9Format format) { return {IsDepthStencilFormat(format) ? 2u : 1u}; }
|
|
struct Unsupported { unsigned elementSize = 0; };
|
|
Unsupported unsupported;
|
|
const Unsupported* UnsupportedFormatInfo(D3D9Format) { return &unsupported; }
|
|
bool IsD3DCompatibile(D3DCompatibility) { return false; }
|
|
void IncrementLosableCounter() { ++losable; }
|
|
template<typename F> void InjectCs(F function) { ++injected; function(&context); }
|
|
};
|
|
HRESULT DecodeMultiSampleType(D3DMULTISAMPLE_TYPE, DWORD, VkSampleCountFlagBits*);
|
|
struct D3D9CommonTexture {
|
|
Rc<DxvkImage> image;
|
|
const Rc<DxvkImage>& GetImage() const { return image; }
|
|
static HRESULT NormalizeTextureProperties(D3D9DeviceEx*, D3DRESOURCETYPE, D3D9_COMMON_TEXTURE_DESC*);
|
|
/* PRODUCTION_USES_IMAGE */
|
|
};
|
|
class DxvkError : public std::runtime_error {
|
|
public:
|
|
using std::runtime_error::runtime_error;
|
|
std::string message() const { return what(); }
|
|
};
|
|
struct Logger { static void err(const std::string&) {} };
|
|
struct D3D9SwapChainEx;
|
|
struct D3D9Surface {
|
|
D3D9CommonTexture texture;
|
|
D3D9DeviceEx* device;
|
|
D3D9Surface(D3D9DeviceEx* d, D3D9_COMMON_TEXTURE_DESC* desc, bool, D3D9SwapChainEx*, void*) : device(d) {
|
|
if (++d->attempts == d->failAt) throw DxvkError("controlled allocation failure");
|
|
VkSampleCountFlagBits samples;
|
|
if (FAILED(DecodeMultiSampleType(desc->MultiSample, desc->MultisampleQuality, &samples)))
|
|
throw DxvkError("invalid backend sample count");
|
|
texture.image = std::make_shared<DxvkImage>(DxvkImage{{{desc->Width, desc->Height}, samples}});
|
|
d->created.push_back(*desc); ++d->live;
|
|
}
|
|
~D3D9Surface() { --device->live; }
|
|
D3D9CommonTexture* GetCommonTexture() { return &texture; }
|
|
};
|
|
struct D3D9SwapChainEx {
|
|
D3D9DeviceEx* m_parent;
|
|
D3DPRESENT_PARAMETERS m_presentParams;
|
|
std::vector<std::unique_ptr<D3D9Surface>> m_backBuffers;
|
|
bool flip = false;
|
|
unsigned destroys = 0;
|
|
bool SwapWithFrontBuffer() { return flip; }
|
|
void DestroyBackBuffers() { ++destroys; m_backBuffers.clear(); }
|
|
HRESULT CreateBackBuffers(uint32_t, DWORD);
|
|
};
|
|
#include "d3d9_production.inc"
|
|
|
|
void paired(bool enabled, D3DMULTISAMPLE_TYPE type, DWORD quality) {
|
|
D3D9DeviceEx device; device.options.forceSingleSample = enabled;
|
|
device.options.extraFrontbuffer = true;
|
|
D3D9SwapChainEx chain{&device, {}, {}};
|
|
chain.m_presentParams.MultiSampleType = type; chain.m_presentParams.MultiSampleQuality = quality;
|
|
assert(chain.CreateBackBuffers(2, 0) == D3D_OK);
|
|
D3D9_COMMON_TEXTURE_DESC depth;
|
|
assert(auto_depth(&device, &chain.m_presentParams, &depth) == D3D_OK);
|
|
VkSampleCountFlagBits requested, dsSamples;
|
|
assert(DecodeMultiSampleType(type, quality, &requested) == D3D_OK);
|
|
assert(DecodeMultiSampleType(depth.MultiSample, depth.MultisampleQuality, &dsSamples) == D3D_OK);
|
|
assert(chain.m_backBuffers.size() == 3 && device.context.initialized == 3);
|
|
for (const auto& surface : chain.m_backBuffers) {
|
|
const auto& image = surface->GetCommonTexture()->GetImage()->info;
|
|
assert(image.sampleCount == (enabled ? 1u : requested));
|
|
assert(depth_binds(image, {{depth.Width, depth.Height}, dsSamples}));
|
|
}
|
|
for (const auto& desc : device.created) {
|
|
assert(desc.IsLockable && desc.IsBackBuffer && !desc.IsAttachmentOnly);
|
|
assert(desc.MultiSample == (enabled ? D3DMULTISAMPLE_NONE : type));
|
|
assert(desc.MultisampleQuality == (enabled ? 0u : quality));
|
|
}
|
|
// Original presentation parameters remain available for reset/auto-depth validation.
|
|
assert(chain.m_presentParams.MultiSampleType == type && chain.m_presentParams.MultiSampleQuality == quality);
|
|
if (enabled && requested > 1) assert(device.adapter.checked.front() == D3DMULTISAMPLE_TYPE(requested));
|
|
}
|
|
|
|
int main(int argc, char** argv) {
|
|
assert(argc == 2); std::string name = argv[1];
|
|
if (name == "forced_msaa_depth") paired(true, D3DMULTISAMPLE_TYPE(4), 0);
|
|
else if (name == "default_msaa_depth") paired(false, D3DMULTISAMPLE_TYPE(4), 0);
|
|
else if (name == "forced_nonmaskable") paired(true, D3DMULTISAMPLE_NONMASKABLE, 2);
|
|
else if (name == "default_nonmaskable") paired(false, D3DMULTISAMPLE_NONMASKABLE, 2);
|
|
else if (name == "forced_already_single") paired(true, D3DMULTISAMPLE_NONE, 0);
|
|
else if (name == "forced_no_depth" || name == "forced_lockable_single") {
|
|
D3D9DeviceEx d; d.options.forceSingleSample = true;
|
|
D3D9SwapChainEx c{&d, {}, {}};
|
|
if (name == "forced_lockable_single") c.m_presentParams.MultiSampleType = D3DMULTISAMPLE_NONE;
|
|
assert(c.CreateBackBuffers(1, name == "forced_lockable_single" ? D3DPRESENTFLAG_LOCKABLE_BACKBUFFER : 0) == D3D_OK);
|
|
assert(c.m_backBuffers.size() == 1 && d.created[0].MultiSample == D3DMULTISAMPLE_NONE);
|
|
assert(d.created[0].IsLockable && d.context.initialized == 1);
|
|
} else if (name == "forced_unsupported" || name == "forced_invalid_type" || name == "forced_lockable_msaa") {
|
|
D3D9DeviceEx d; d.options.forceSingleSample = true;
|
|
D3D9SwapChainEx c{&d, {}, {}};
|
|
if (name == "forced_unsupported") d.adapter.supported = false;
|
|
if (name == "forced_invalid_type") c.m_presentParams.MultiSampleType = D3DMULTISAMPLE_TYPE(17);
|
|
HRESULT expected = name == "forced_unsupported" ? D3DERR_NOTAVAILABLE : D3DERR_INVALIDCALL;
|
|
assert(c.CreateBackBuffers(2, name == "forced_lockable_msaa" ? D3DPRESENTFLAG_LOCKABLE_BACKBUFFER : 0) == expected);
|
|
assert(d.attempts == 0 && d.losable == 0 && d.injected == 0 && c.m_backBuffers.empty());
|
|
} else if (name == "forced_allocation_failure" || name == "default_allocation_failure") {
|
|
D3D9DeviceEx d; d.options.forceSingleSample = name == "forced_allocation_failure"; d.failAt = 2;
|
|
D3D9SwapChainEx c{&d, {}, {}};
|
|
assert(c.CreateBackBuffers(3, 0) == D3DERR_OUTOFVIDEOMEMORY);
|
|
assert(d.attempts == 2 && d.losable == 1 && d.live == 0 && d.injected == 0 && c.m_backBuffers.empty());
|
|
} else if (name == "forced_recreate") {
|
|
D3D9DeviceEx d; d.options.forceSingleSample = true;
|
|
D3D9SwapChainEx c{&d, {}, {}};
|
|
assert(c.CreateBackBuffers(3, 0) == D3D_OK);
|
|
c.m_presentParams.MultiSampleType = D3DMULTISAMPLE_TYPE(8);
|
|
assert(c.CreateBackBuffers(1, 0) == D3D_OK);
|
|
assert(d.live == 1 && c.m_backBuffers.size() == 1 && c.destroys == 2);
|
|
assert(d.adapter.checked.size() == 2 && d.adapter.checked.back() == D3DMULTISAMPLE_TYPE(8));
|
|
assert(c.m_backBuffers[0]->GetCommonTexture()->GetImage()->info.sampleCount == 1);
|
|
} else if (name == "ordinary_surface" || name == "ordinary_invalid_lockable") {
|
|
D3D9DeviceEx d; d.options.forceSingleSample = true;
|
|
D3D9_COMMON_TEXTURE_DESC desc; desc.MultiSample = D3DMULTISAMPLE_TYPE(4);
|
|
desc.IsLockable = name == "ordinary_invalid_lockable";
|
|
assert(D3D9CommonTexture::NormalizeTextureProperties(&d, D3DRTYPE_SURFACE, &desc)
|
|
== (desc.IsLockable ? D3DERR_INVALIDCALL : D3D_OK));
|
|
if (!desc.IsLockable) assert(desc.MultiSample == D3DMULTISAMPLE_NONE && desc.MultisampleQuality == 0);
|
|
} else assert(false);
|
|
return 0;
|
|
}
|