mirror of
https://github.com/Droid-Deck/DroidDeck.git
synced 2026-11-19 04:46:08 +00:00
Squash of Droid-Deck/DroidDeck#517 (ASEbrahim/DroidDeck mali-bridge @ 6b823341): the Vulkan
bridge (tools/vkbridge) that runs the guest's Vulkan on the phone's own driver, with BC1-BC7,
clip/cull distance, vertex-divisor and depth-clip emulation and dma-heap memory sharing for Mali.
All of the bridge is ASEbrahim's work; squashed only to carry it on this test branch.
Combined with #570 on this branch, a device draws through exactly one path:
- Adreno: Turnip, unchanged (checked first; the bridge setting is ignored there).
- PowerVR / Xclipse with the system HAL and a render node: the system-Vulkan path (#570).
- Anything else with the Setup toggle on (Mali): the bridge.
367 lines
17 KiB
C
367 lines
17 KiB
C
/* SPDX-License-Identifier: GPL-3.0-or-later
|
|
*
|
|
* d3d11_check.exe - checks the D3D11 features the Mali bridge emulates, through DXVK, by reading
|
|
* back pixels: BC1/BC3/BC4/BC5/BC7 sampling, SV_ClipDistance, instance data step rates
|
|
* (vertex attribute divisor), plus a plain clear and draw. Prints PASS/FAIL lines; exit 0 = all.
|
|
*
|
|
* Built with mingw-w64: x86_64-w64-mingw32-gcc -O2 d3d11_check.c -o d3d11_check.exe -ld3d11 -ld3dcompiler_47 -ldxgi
|
|
*/
|
|
#define COBJMACROS
|
|
#define INITGUID
|
|
#include <windows.h>
|
|
#include <d3d11.h>
|
|
#include <d3dcompiler.h>
|
|
#include <stdint.h>
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
|
|
static ID3D11Device *dev;
|
|
static ID3D11DeviceContext *ctx;
|
|
static ID3D11Texture2D *rt, *staging;
|
|
static ID3D11RenderTargetView *rtv;
|
|
static int failures, checks;
|
|
#define TW 64
|
|
#define TH 64
|
|
|
|
static void check(int ok, const char *what, const char *detail)
|
|
{
|
|
checks++;
|
|
if (!ok) failures++;
|
|
printf("%s %s%s%s\n", ok ? "PASS" : "FAIL", what, detail && *detail ? ": " : "", detail ? detail : "");
|
|
fflush(stdout);
|
|
}
|
|
|
|
static ID3DBlob *compile(const char *src, const char *entry, const char *target)
|
|
{
|
|
ID3DBlob *code = NULL, *err = NULL;
|
|
HRESULT hr = D3DCompile(src, strlen(src), NULL, NULL, NULL, entry, target, 0, 0, &code, &err);
|
|
if (FAILED(hr)) {
|
|
printf("shader %s failed: %s\n", entry, err ? (const char *)ID3D10Blob_GetBufferPointer(err) : "?");
|
|
return NULL;
|
|
}
|
|
return code;
|
|
}
|
|
|
|
/* Reads the render target back; returns a pointer valid until the next call. */
|
|
static const uint32_t *readback(void)
|
|
{
|
|
static uint32_t px[TW * TH];
|
|
ID3D11DeviceContext_CopyResource(ctx, (ID3D11Resource *)staging, (ID3D11Resource *)rt);
|
|
D3D11_MAPPED_SUBRESOURCE m;
|
|
if (FAILED(ID3D11DeviceContext_Map(ctx, (ID3D11Resource *)staging, 0, D3D11_MAP_READ, 0, &m))) return NULL;
|
|
for (int y = 0; y < TH; y++) memcpy(px + y * TW, (const uint8_t *)m.pData + y * m.RowPitch, TW * 4);
|
|
ID3D11DeviceContext_Unmap(ctx, (ID3D11Resource *)staging, 0);
|
|
return px;
|
|
}
|
|
|
|
static int close_to(uint32_t a, uint32_t b, int tol)
|
|
{
|
|
for (int i = 0; i < 32; i += 8) {
|
|
int d = (int)((a >> i) & 0xff) - (int)((b >> i) & 0xff);
|
|
if (d < -tol || d > tol) return 0;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
static void clear(float r, float g, float b)
|
|
{
|
|
float c[4] = {r, g, b, 1};
|
|
ID3D11DeviceContext_ClearRenderTargetView(ctx, rtv, c);
|
|
}
|
|
|
|
static void bind_target(void)
|
|
{
|
|
ID3D11DeviceContext_OMSetRenderTargets(ctx, 1, &rtv, NULL);
|
|
D3D11_VIEWPORT vp = {0, 0, TW, TH, 0, 1};
|
|
ID3D11DeviceContext_RSSetViewports(ctx, 1, &vp);
|
|
}
|
|
|
|
/* ------------------------------------------------------------------ textures */
|
|
|
|
static const char *tex_vs =
|
|
"struct O { float4 p : SV_Position; float2 uv : TEXCOORD; };"
|
|
"O main(uint id : SV_VertexID) { O o; float2 t = float2((id << 1) & 2, id & 2);"
|
|
"o.p = float4(t * float2(2, -2) + float2(-1, 1), 0, 1); o.uv = t; return o; }";
|
|
static const char *tex_ps =
|
|
"Texture2D t : register(t0); SamplerState s : register(s0);"
|
|
"float4 main(float4 p : SV_Position, float2 uv : TEXCOORD) : SV_Target { return t.Sample(s, uv); }";
|
|
|
|
/* One 8x8 texture of 2x2 blocks, each block a solid colour. Returns RGBA8 (A in top byte). */
|
|
static void test_bc(DXGI_FORMAT fmt, const char *name, const void *blocks, size_t block_bytes, const uint32_t want[4], int tol)
|
|
{
|
|
D3D11_TEXTURE2D_DESC td = {8, 8, 1, 1, fmt, {1, 0}, D3D11_USAGE_DEFAULT, D3D11_BIND_SHADER_RESOURCE, 0, 0};
|
|
D3D11_SUBRESOURCE_DATA init = {blocks, (UINT)(block_bytes * 2), 0};
|
|
ID3D11Texture2D *tex = NULL;
|
|
HRESULT hr = ID3D11Device_CreateTexture2D(dev, &td, &init, &tex);
|
|
if (FAILED(hr)) {
|
|
char d[64];
|
|
snprintf(d, sizeof d, "CreateTexture2D 0x%08lx", (unsigned long)hr);
|
|
check(0, name, d);
|
|
return;
|
|
}
|
|
ID3D11ShaderResourceView *srv;
|
|
ID3D11Device_CreateShaderResourceView(dev, (ID3D11Resource *)tex, NULL, &srv);
|
|
D3D11_SAMPLER_DESC sd = {D3D11_FILTER_MIN_MAG_MIP_POINT, D3D11_TEXTURE_ADDRESS_CLAMP, D3D11_TEXTURE_ADDRESS_CLAMP,
|
|
D3D11_TEXTURE_ADDRESS_CLAMP, 0, 1, D3D11_COMPARISON_NEVER, {0}, 0, D3D11_FLOAT32_MAX};
|
|
ID3D11SamplerState *smp;
|
|
ID3D11Device_CreateSamplerState(dev, &sd, &smp);
|
|
static ID3D11VertexShader *vs;
|
|
static ID3D11PixelShader *ps;
|
|
if (!vs) {
|
|
ID3DBlob *v = compile(tex_vs, "main", "vs_5_0"), *p = compile(tex_ps, "main", "ps_5_0");
|
|
ID3D11Device_CreateVertexShader(dev, ID3D10Blob_GetBufferPointer(v), ID3D10Blob_GetBufferSize(v), NULL, &vs);
|
|
ID3D11Device_CreatePixelShader(dev, ID3D10Blob_GetBufferPointer(p), ID3D10Blob_GetBufferSize(p), NULL, &ps);
|
|
}
|
|
bind_target();
|
|
clear(0, 0, 0);
|
|
ID3D11DeviceContext_IASetInputLayout(ctx, NULL);
|
|
ID3D11DeviceContext_IASetPrimitiveTopology(ctx, D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
|
|
ID3D11DeviceContext_VSSetShader(ctx, vs, NULL, 0);
|
|
ID3D11DeviceContext_PSSetShader(ctx, ps, NULL, 0);
|
|
ID3D11DeviceContext_PSSetShaderResources(ctx, 0, 1, &srv);
|
|
ID3D11DeviceContext_PSSetSamplers(ctx, 0, 1, &smp);
|
|
ID3D11DeviceContext_Draw(ctx, 3, 0);
|
|
const uint32_t *px = readback();
|
|
/* quadrant centres: TL, TR, BL, BR */
|
|
int pts[4][2] = {{TW / 4, TH / 4}, {3 * TW / 4, TH / 4}, {TW / 4, 3 * TH / 4}, {3 * TW / 4, 3 * TH / 4}};
|
|
char d[160] = "";
|
|
int ok = px != NULL;
|
|
for (int i = 0; ok && i < 4; i++) {
|
|
uint32_t v = px[pts[i][1] * TW + pts[i][0]];
|
|
if (!close_to(v, want[i], tol)) {
|
|
snprintf(d, sizeof d, "block %d = 0x%08x, want 0x%08x", i, v, want[i]);
|
|
ok = 0;
|
|
}
|
|
}
|
|
check(ok, name, ok ? "4 blocks decode to the right colours" : d);
|
|
}
|
|
|
|
static void tests_bc(void)
|
|
{
|
|
/* BC1: colour0 = colour1 = solid; indices 0. RGB565 values -> 8-bit. */
|
|
uint16_t c[4] = {0xF800, 0x07E0, 0x001F, 0xFFFF}; /* red, green, blue, white */
|
|
uint8_t bc1[4][8];
|
|
for (int i = 0; i < 4; i++) {
|
|
memcpy(bc1[i], &c[i], 2);
|
|
memcpy(bc1[i] + 2, &c[i], 2);
|
|
memset(bc1[i] + 4, 0, 4);
|
|
}
|
|
/* layout: block row 0 = blocks 0,1; row 1 = 2,3 */
|
|
uint32_t want1[4] = {0xFF0000FF, 0xFF00FF00, 0xFFFF0000, 0xFFFFFFFF};
|
|
test_bc(DXGI_FORMAT_BC1_UNORM, "BC1 texture", bc1, 8, want1, 8);
|
|
|
|
/* BC3: alpha 255 (alpha endpoints 255,255) + BC1 colour block. */
|
|
uint8_t bc3[4][16];
|
|
for (int i = 0; i < 4; i++) {
|
|
memset(bc3[i], 0, 16);
|
|
bc3[i][0] = bc3[i][1] = 0xFF;
|
|
memcpy(bc3[i] + 8, bc1[i], 8);
|
|
}
|
|
test_bc(DXGI_FORMAT_BC3_UNORM, "BC3 texture", bc3, 16, want1, 8);
|
|
|
|
/* BC4: single channel; endpoints = value. Sampled as R, G=B=0, A=1. */
|
|
uint8_t vals[4] = {255, 128, 64, 0};
|
|
uint8_t bc4[4][8];
|
|
uint32_t want4[4];
|
|
for (int i = 0; i < 4; i++) {
|
|
memset(bc4[i], 0, 8);
|
|
bc4[i][0] = bc4[i][1] = vals[i];
|
|
want4[i] = 0xFF000000u | vals[i];
|
|
}
|
|
test_bc(DXGI_FORMAT_BC4_UNORM, "BC4 texture", bc4, 8, want4, 2);
|
|
|
|
/* BC5: two channels (R from first half, G from second). */
|
|
uint8_t bc5[4][16];
|
|
uint32_t want5[4];
|
|
for (int i = 0; i < 4; i++) {
|
|
memset(bc5[i], 0, 16);
|
|
bc5[i][0] = bc5[i][1] = vals[i];
|
|
bc5[i][8] = bc5[i][9] = vals[3 - i];
|
|
want5[i] = 0xFF000000u | vals[i] | ((uint32_t)vals[3 - i] << 8);
|
|
}
|
|
test_bc(DXGI_FORMAT_BC5_UNORM, "BC5 texture", bc5, 16, want5, 2);
|
|
|
|
/* BC7 mode 6: endpoints RGBA 7+1 bits; solid colour when both endpoints are equal. Encoded
|
|
* below by bit packing: mode 6 = bit 6 set (bits 0-6 = 1000000b). */
|
|
uint8_t bc7[4][16];
|
|
uint32_t want7[4];
|
|
uint8_t cols[4][3] = {{255, 0, 0}, {0, 255, 0}, {0, 0, 255}, {255, 255, 255}};
|
|
for (int i = 0; i < 4; i++) {
|
|
uint8_t blk[16] = {0};
|
|
int bit = 0;
|
|
#define PUT(v, n) do { for (int k_ = 0; k_ < (n); k_++, bit++) if (((v) >> k_) & 1) blk[bit >> 3] |= (uint8_t)(1u << (bit & 7)); } while (0)
|
|
PUT(1u << 6, 7); /* mode 6 */
|
|
for (int ch = 0; ch < 3; ch++) { PUT(cols[i][ch] >> 1, 7); PUT(cols[i][ch] >> 1, 7); }
|
|
PUT(127, 7); PUT(127, 7); /* alpha endpoints */
|
|
PUT(cols[i][0] & 1, 1); PUT(cols[i][0] & 1, 1); /* p-bits (same for all channels) */
|
|
#undef PUT
|
|
memcpy(bc7[i], blk, 16);
|
|
uint8_t r = cols[i][0], g = cols[i][1], b = cols[i][2];
|
|
/* 7-bit value + shared p-bit */
|
|
uint8_t p = cols[i][0] & 1;
|
|
r = (uint8_t)(((r >> 1) << 1) | p);
|
|
g = (uint8_t)(((g >> 1) << 1) | p);
|
|
b = (uint8_t)(((b >> 1) << 1) | p);
|
|
want7[i] = 0xFF000000u | r | ((uint32_t)g << 8) | ((uint32_t)b << 16);
|
|
}
|
|
test_bc(DXGI_FORMAT_BC7_UNORM, "BC7 texture", bc7, 16, want7, 3);
|
|
}
|
|
|
|
/* ------------------------------------------------------------------ clip distance */
|
|
|
|
static void test_clip(void)
|
|
{
|
|
const char *vs =
|
|
"struct O { float4 p : SV_Position; float c : SV_ClipDistance0; };"
|
|
"O main(uint id : SV_VertexID) { O o; float2 t = float2((id << 1) & 2, id & 2);"
|
|
"o.p = float4(t * float2(2, -2) + float2(-1, 1), 0, 1); o.c = o.p.x; return o; }";
|
|
const char *ps = "float4 main() : SV_Target { return float4(0, 1, 0, 1); }";
|
|
ID3DBlob *v = compile(vs, "main", "vs_5_0"), *p = compile(ps, "main", "ps_5_0");
|
|
if (!v || !p) {
|
|
check(0, "clip distance", "shader compile");
|
|
return;
|
|
}
|
|
ID3D11VertexShader *vsh;
|
|
ID3D11PixelShader *psh;
|
|
ID3D11Device_CreateVertexShader(dev, ID3D10Blob_GetBufferPointer(v), ID3D10Blob_GetBufferSize(v), NULL, &vsh);
|
|
ID3D11Device_CreatePixelShader(dev, ID3D10Blob_GetBufferPointer(p), ID3D10Blob_GetBufferSize(p), NULL, &psh);
|
|
bind_target();
|
|
clear(1, 0, 0);
|
|
ID3D11DeviceContext_IASetInputLayout(ctx, NULL);
|
|
ID3D11DeviceContext_IASetPrimitiveTopology(ctx, D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
|
|
ID3D11DeviceContext_VSSetShader(ctx, vsh, NULL, 0);
|
|
ID3D11DeviceContext_PSSetShader(ctx, psh, NULL, 0);
|
|
ID3D11DeviceContext_Draw(ctx, 3, 0);
|
|
const uint32_t *px = readback();
|
|
int ok = px && close_to(px[TH / 2 * TW + TW / 4], 0xFF0000FF, 2) && close_to(px[TH / 2 * TW + 3 * TW / 4], 0xFF00FF00, 2);
|
|
char d[96];
|
|
snprintf(d, sizeof d, "left 0x%08x (want red), right 0x%08x (want green)", px ? px[TH / 2 * TW + TW / 4] : 0,
|
|
px ? px[TH / 2 * TW + 3 * TW / 4] : 0);
|
|
check(ok, "SV_ClipDistance", d);
|
|
}
|
|
|
|
/* ------------------------------------------------------------------ instance step rate */
|
|
|
|
static void test_step_rate(void)
|
|
{
|
|
/* Four instances of a quad column; per-instance colour with step rate 2: instances 0-1 get
|
|
* colour 0 (blue), 2-3 colour 1 (yellow). Each instance covers a quarter of the width. */
|
|
const char *vs =
|
|
"struct I { uint id : SV_VertexID; uint inst : SV_InstanceID; float4 col : COLOR; };"
|
|
"struct O { float4 p : SV_Position; float4 col : COLOR; };"
|
|
"O main(I i) { O o; float2 t = float2((i.id << 1) & 2, i.id & 2) * 0.5; /* 0..1 tri covering a quad's lower-left half */"
|
|
"float x0 = -1 + 0.5 * i.inst; float2 q = float2(i.id == 1 ? 1 : 0, i.id == 2 ? 1 : 0);"
|
|
"float2 pos[6] = { float2(0,0), float2(1,0), float2(0,1), float2(1,0), float2(1,1), float2(0,1) };"
|
|
"float2 v = pos[i.id]; o.p = float4(x0 + v.x * 0.5, -1 + v.y * 2, 0, 1); o.col = i.col; return o; }";
|
|
const char *ps = "float4 main(float4 p : SV_Position, float4 c : COLOR) : SV_Target { return c; }";
|
|
ID3DBlob *v = compile(vs, "main", "vs_5_0"), *p = compile(ps, "main", "ps_5_0");
|
|
if (!v || !p) {
|
|
check(0, "instance step rate", "shader compile");
|
|
return;
|
|
}
|
|
ID3D11VertexShader *vsh;
|
|
ID3D11PixelShader *psh;
|
|
ID3D11Device_CreateVertexShader(dev, ID3D10Blob_GetBufferPointer(v), ID3D10Blob_GetBufferSize(v), NULL, &vsh);
|
|
ID3D11Device_CreatePixelShader(dev, ID3D10Blob_GetBufferPointer(p), ID3D10Blob_GetBufferSize(p), NULL, &psh);
|
|
D3D11_INPUT_ELEMENT_DESC el = {"COLOR", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, 0, D3D11_INPUT_PER_INSTANCE_DATA, 2};
|
|
ID3D11InputLayout *il;
|
|
HRESULT hr = ID3D11Device_CreateInputLayout(dev, &el, 1, ID3D10Blob_GetBufferPointer(v), ID3D10Blob_GetBufferSize(v), &il);
|
|
if (FAILED(hr)) {
|
|
check(0, "instance step rate", "CreateInputLayout");
|
|
return;
|
|
}
|
|
float cols[2][4] = {{0, 0, 1, 1}, {1, 1, 0, 1}};
|
|
D3D11_BUFFER_DESC bd = {sizeof cols, D3D11_USAGE_DEFAULT, D3D11_BIND_VERTEX_BUFFER, 0, 0, 0};
|
|
D3D11_SUBRESOURCE_DATA init = {cols, 0, 0};
|
|
ID3D11Buffer *vb;
|
|
ID3D11Device_CreateBuffer(dev, &bd, &init, &vb);
|
|
UINT stride = 16, offset = 0;
|
|
D3D11_RASTERIZER_DESC rd = {D3D11_FILL_SOLID, D3D11_CULL_NONE, FALSE, 0, 0, 0, TRUE, FALSE, FALSE, FALSE};
|
|
ID3D11RasterizerState *rs;
|
|
ID3D11Device_CreateRasterizerState(dev, &rd, &rs);
|
|
ID3D11DeviceContext_RSSetState(ctx, rs);
|
|
bind_target();
|
|
clear(0, 0, 0);
|
|
ID3D11DeviceContext_IASetInputLayout(ctx, il);
|
|
ID3D11DeviceContext_IASetVertexBuffers(ctx, 0, 1, &vb, &stride, &offset);
|
|
ID3D11DeviceContext_IASetPrimitiveTopology(ctx, D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
|
|
ID3D11DeviceContext_VSSetShader(ctx, vsh, NULL, 0);
|
|
ID3D11DeviceContext_PSSetShader(ctx, psh, NULL, 0);
|
|
ID3D11DeviceContext_DrawInstanced(ctx, 6, 4, 0, 0);
|
|
const uint32_t *px = readback();
|
|
uint32_t want[4] = {0xFFFF0000, 0xFFFF0000, 0xFF00FFFF, 0xFF00FFFF};
|
|
int ok = px != NULL;
|
|
char d[128] = "instances 0-1 blue, 2-3 yellow";
|
|
for (int i = 0; ok && i < 4; i++) {
|
|
uint32_t got = px[TH / 2 * TW + i * TW / 4 + TW / 8];
|
|
if (!close_to(got, want[i], 2)) {
|
|
snprintf(d, sizeof d, "instance %d = 0x%08x, want 0x%08x", i, got, want[i]);
|
|
ok = 0;
|
|
}
|
|
}
|
|
check(ok, "instance step rate 2", d);
|
|
}
|
|
|
|
/* ------------------------------------------------------------------ depth clip */
|
|
|
|
static void test_depth_clip(void)
|
|
{
|
|
/* A full-screen triangle at z = 1.5 (beyond the far plane): clipped away with depth clip on,
|
|
* visible (clamped to the far plane) with it off. */
|
|
const char *vs = "float4 main(uint id : SV_VertexID) : SV_Position { float2 t = float2((id << 1) & 2, id & 2);"
|
|
"return float4(t * float2(2, -2) + float2(-1, 1), 1.5, 1); }";
|
|
const char *ps = "float4 main() : SV_Target { return float4(1, 1, 1, 1); }";
|
|
ID3DBlob *v = compile(vs, "main", "vs_5_0"), *p = compile(ps, "main", "ps_5_0");
|
|
ID3D11VertexShader *vsh;
|
|
ID3D11PixelShader *psh;
|
|
ID3D11Device_CreateVertexShader(dev, ID3D10Blob_GetBufferPointer(v), ID3D10Blob_GetBufferSize(v), NULL, &vsh);
|
|
ID3D11Device_CreatePixelShader(dev, ID3D10Blob_GetBufferPointer(p), ID3D10Blob_GetBufferSize(p), NULL, &psh);
|
|
uint32_t got[2];
|
|
for (int on = 1; on >= 0; on--) {
|
|
D3D11_RASTERIZER_DESC rd = {D3D11_FILL_SOLID, D3D11_CULL_NONE, FALSE, 0, 0, 0, on ? TRUE : FALSE, FALSE, FALSE, FALSE};
|
|
ID3D11RasterizerState *rs;
|
|
ID3D11Device_CreateRasterizerState(dev, &rd, &rs);
|
|
ID3D11DeviceContext_RSSetState(ctx, rs);
|
|
bind_target();
|
|
clear(0, 0, 0);
|
|
ID3D11DeviceContext_IASetInputLayout(ctx, NULL);
|
|
ID3D11DeviceContext_IASetPrimitiveTopology(ctx, D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
|
|
ID3D11DeviceContext_VSSetShader(ctx, vsh, NULL, 0);
|
|
ID3D11DeviceContext_PSSetShader(ctx, psh, NULL, 0);
|
|
ID3D11DeviceContext_Draw(ctx, 3, 0);
|
|
const uint32_t *px = readback();
|
|
got[on] = px ? px[TH / 2 * TW + TW / 2] : 0;
|
|
}
|
|
ID3D11DeviceContext_RSSetState(ctx, NULL);
|
|
char d[96];
|
|
snprintf(d, sizeof d, "clip on 0x%08x (want black), off 0x%08x (want white)", got[1], got[0]);
|
|
check(close_to(got[1], 0xFF000000, 2) && close_to(got[0], 0xFFFFFFFF, 2), "DepthClipEnable", d);
|
|
}
|
|
|
|
int main(void)
|
|
{
|
|
D3D_FEATURE_LEVEL fl = D3D_FEATURE_LEVEL_11_0, got;
|
|
HRESULT hr = D3D11CreateDevice(NULL, D3D_DRIVER_TYPE_HARDWARE, NULL, 0, &fl, 1, D3D11_SDK_VERSION, &dev, &got, &ctx);
|
|
char d[64];
|
|
snprintf(d, sizeof d, "hr 0x%08lx", (unsigned long)hr);
|
|
check(SUCCEEDED(hr), "D3D11 device (feature level 11_0)", SUCCEEDED(hr) ? "" : d);
|
|
if (FAILED(hr)) return 1;
|
|
D3D11_TEXTURE2D_DESC td = {TW, TH, 1, 1, DXGI_FORMAT_R8G8B8A8_UNORM, {1, 0}, D3D11_USAGE_DEFAULT, D3D11_BIND_RENDER_TARGET, 0, 0};
|
|
ID3D11Device_CreateTexture2D(dev, &td, NULL, &rt);
|
|
ID3D11Device_CreateRenderTargetView(dev, (ID3D11Resource *)rt, NULL, &rtv);
|
|
td.Usage = D3D11_USAGE_STAGING;
|
|
td.BindFlags = 0;
|
|
td.CPUAccessFlags = D3D11_CPU_ACCESS_READ;
|
|
ID3D11Device_CreateTexture2D(dev, &td, NULL, &staging);
|
|
bind_target();
|
|
clear(0.25f, 0.5f, 0.75f);
|
|
const uint32_t *px = readback();
|
|
check(px && close_to(px[0], 0xFFBF8040, 2), "clear + readback", "");
|
|
tests_bc();
|
|
test_clip();
|
|
test_step_rate();
|
|
test_depth_clip();
|
|
printf("%s: %d of %d checks passed\n", failures ? "FAILED" : "OK", checks - failures, checks);
|
|
return failures ? 1 : 0;
|
|
}
|