BlackMark
9a736cf477
The animated pattern math (background sweep, moving 24px bar, frame- counter block) was copy-pasted across all five clear-based backends (dx9/dx10/dx11/dx12/gl). The backends MUST render an identical image -- the capture test decodes the same frame-counter block from each -- so a drift between copies would be a silent test hazard. Factor it into one frame_pattern() helper (plus kBarWidth) in render_backend.hpp; each backend now consumes the computed bg/bar_x/code values with its own API's clear/fill. mock_game_test still decodes every backend correctly.
126 lines
3.9 KiB
C++
126 lines
3.9 KiB
C++
// DX10 backend for the mock game. DX10 has no rect-clear (ClearView), so it composes the
|
|
// animated pattern (background + moving bar + top-left frame-counter block) into a CPU buffer
|
|
// each frame, uploads it into a scratch texture, and CopyResource's that into the swap-chain
|
|
// back buffer -- no shaders. It presents through a real D3D10 DXGI swap chain, so the capture
|
|
// hook sees a genuine D3D10 present.
|
|
#include "render_backend.hpp"
|
|
|
|
#include <vector>
|
|
|
|
#include <d3d10.h>
|
|
#include <dxgi.h>
|
|
#include <wrl/client.h>
|
|
|
|
using Microsoft::WRL::ComPtr;
|
|
|
|
namespace coop::mock
|
|
{
|
|
namespace
|
|
{
|
|
std::uint32_t pack(std::uint8_t r, std::uint8_t g, std::uint8_t b, std::uint8_t a = 255)
|
|
{
|
|
// R8G8B8A8_UNORM byte order: R in the low byte.
|
|
return static_cast<std::uint32_t>(r) | (static_cast<std::uint32_t>(g) << 8) |
|
|
(static_cast<std::uint32_t>(b) << 16) | (static_cast<std::uint32_t>(a) << 24);
|
|
}
|
|
|
|
class Dx10Backend : public RenderBackend
|
|
{
|
|
public:
|
|
bool init(HWND hwnd, std::uint32_t width, std::uint32_t height) override
|
|
{
|
|
width_ = width;
|
|
height_ = height;
|
|
px_.resize(static_cast<std::size_t>(width) * height);
|
|
|
|
DXGI_SWAP_CHAIN_DESC desc = {};
|
|
desc.BufferDesc.Width = width;
|
|
desc.BufferDesc.Height = height;
|
|
desc.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM; // UNORM (not sRGB) so the frame code is exact
|
|
desc.BufferDesc.RefreshRate.Numerator = 60;
|
|
desc.BufferDesc.RefreshRate.Denominator = 1;
|
|
desc.SampleDesc.Count = 1;
|
|
desc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
|
|
desc.BufferCount = 2;
|
|
desc.OutputWindow = hwnd;
|
|
desc.Windowed = TRUE;
|
|
desc.SwapEffect = DXGI_SWAP_EFFECT_DISCARD; // blt model: GetBuffer(0) is the back buffer
|
|
|
|
if (FAILED(D3D10CreateDeviceAndSwapChain(nullptr, D3D10_DRIVER_TYPE_HARDWARE, nullptr, 0,
|
|
D3D10_SDK_VERSION, &desc, swap_.GetAddressOf(),
|
|
device_.GetAddressOf())))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// Scratch texture matching the back buffer; we upload the CPU frame into it then
|
|
// CopyResource it into the back buffer (DX10 can't fill a sub-rect of an RTV directly).
|
|
D3D10_TEXTURE2D_DESC td = {};
|
|
td.Width = width;
|
|
td.Height = height;
|
|
td.MipLevels = 1;
|
|
td.ArraySize = 1;
|
|
td.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
|
|
td.SampleDesc.Count = 1;
|
|
td.Usage = D3D10_USAGE_DEFAULT;
|
|
td.BindFlags = D3D10_BIND_SHADER_RESOURCE;
|
|
return SUCCEEDED(device_->CreateTexture2D(&td, nullptr, scratch_.GetAddressOf()));
|
|
}
|
|
|
|
void render_and_present(std::uint32_t frame) override
|
|
{
|
|
const FramePattern p = frame_pattern(frame, width_);
|
|
const std::uint32_t bg = pack(p.bg_r, p.bg_g, p.bg_b);
|
|
const std::uint32_t whitepx = pack(255, 255, 255);
|
|
const std::uint32_t code = pack(p.code_r, p.code_g, p.code_b);
|
|
|
|
const std::uint32_t bx = p.bar_x; // moving vertical bar
|
|
for (std::uint32_t y = 0; y < height_; ++y)
|
|
{
|
|
std::uint32_t* row = px_.data() + static_cast<std::size_t>(y) * width_;
|
|
for (std::uint32_t x = 0; x < width_; ++x)
|
|
{
|
|
std::uint32_t c = bg;
|
|
if (x >= bx && x < bx + kBarWidth)
|
|
{
|
|
c = whitepx;
|
|
}
|
|
if (x < kFrameBlock && y < kFrameBlock)
|
|
{
|
|
c = code; // top-left frame-counter block
|
|
}
|
|
row[x] = c;
|
|
}
|
|
}
|
|
|
|
device_->UpdateSubresource(scratch_.Get(), 0, nullptr, px_.data(), static_cast<UINT>(width_ * 4), 0);
|
|
ComPtr<ID3D10Texture2D> back;
|
|
if (SUCCEEDED(swap_->GetBuffer(0, IID_PPV_ARGS(back.GetAddressOf()))))
|
|
{
|
|
device_->CopyResource(back.Get(), scratch_.Get());
|
|
}
|
|
swap_->Present(0, 0); // uncapped (BLT model): the mock does nothing -> it must be fast
|
|
}
|
|
|
|
[[nodiscard]] const char* name() const override
|
|
{
|
|
return "dx10";
|
|
}
|
|
|
|
private:
|
|
std::uint32_t width_ = 0;
|
|
std::uint32_t height_ = 0;
|
|
std::vector<std::uint32_t> px_;
|
|
ComPtr<ID3D10Device> device_;
|
|
ComPtr<IDXGISwapChain> swap_;
|
|
ComPtr<ID3D10Texture2D> scratch_;
|
|
};
|
|
} // namespace
|
|
|
|
std::unique_ptr<RenderBackend> create_dx10_backend()
|
|
{
|
|
return std::make_unique<Dx10Backend>();
|
|
}
|
|
|
|
} // namespace coop::mock
|