Mali bridge (#517, by ASEbrahim) on the non-Adreno test branch

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.
This commit is contained in:
The412Banner committed 2026-10-12 18:34:49 -04:00
1 parent cf06f89c11
commit ee0fb08268
125 files changed
+119982 -12

No files matched your search

+319
View File
@@ -0,0 +1,319 @@
/* SPDX-License-Identifier: GPL-3.0-or-later
*
* bcn_check: uploads random blocks of every BC format (every BC6H and BC7 mode forced in turn),
* blits the texture to RGBA32F and compares each texel with bcdec's CPU decode. Run it natively
* (the GPU's own BC decoder) and through the bridge with BC emulated.
*/
#define VK_NO_PROTOTYPES
#include <vulkan/vulkan.h>
#include <dlfcn.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define BCDEC_IMPLEMENTATION
#define BCDEC_BC4BC5_PRECISE
#include "../third_party/bcdec/bcdec.h"
#define TEX 64 /* 16x16 blocks */
static PFN_vkGetInstanceProcAddr gipa;
static VkInstance inst;
static VkPhysicalDevice pd;
static VkDevice dev;
static VkQueue queue;
static VkCommandPool pool;
static VkPhysicalDeviceMemoryProperties mp;
#define F(n) static PFN_##n n
F(vkCreateInstance); F(vkEnumeratePhysicalDevices); F(vkGetPhysicalDeviceMemoryProperties); F(vkCreateDevice);
F(vkGetDeviceProcAddr); F(vkGetPhysicalDeviceFeatures); F(vkGetPhysicalDeviceFormatProperties); F(vkGetDeviceQueue);
F(vkCreateCommandPool); F(vkAllocateCommandBuffers); F(vkBeginCommandBuffer); F(vkEndCommandBuffer); F(vkQueueSubmit);
F(vkQueueWaitIdle); F(vkCreateBuffer); F(vkGetBufferMemoryRequirements); F(vkAllocateMemory); F(vkBindBufferMemory);
F(vkMapMemory); F(vkCreateImage); F(vkGetImageMemoryRequirements); F(vkBindImageMemory); F(vkCmdPipelineBarrier);
F(vkCmdCopyBufferToImage); F(vkCmdBlitImage); F(vkCmdCopyImageToBuffer); F(vkDestroyImage); F(vkDestroyBuffer);
F(vkFreeMemory); F(vkGetPhysicalDeviceProperties);
#undef F
static uint32_t find_type(uint32_t bits, VkMemoryPropertyFlags want)
{
for (uint32_t i = 0; i < mp.memoryTypeCount; i++)
if ((bits & (1u << i)) && (mp.memoryTypes[i].propertyFlags & want) == want) return i;
for (uint32_t i = 0; i < mp.memoryTypeCount; i++)
if (bits & (1u << i)) return i;
return 0;
}
static VkDeviceMemory bind_mem(VkMemoryRequirements r, VkMemoryPropertyFlags want)
{
VkMemoryAllocateInfo ai = {VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO, NULL, r.size, find_type(r.memoryTypeBits, want)};
VkDeviceMemory m;
vkAllocateMemory(dev, &ai, NULL, &m);
return m;
}
static uint64_t rng = 0x9E3779B97F4A7C15ull;
static uint32_t rnd(void)
{
rng ^= rng << 13;
rng ^= rng >> 7;
rng ^= rng << 17;
return (uint32_t)(rng >> 16);
}
/* Random block; for BC6H/BC7 the mode is chosen by `mode` (cycled per block). */
static void make_block(VkFormat f, uint8_t *b, int bytes, int mode)
{
for (int i = 0; i < bytes; i++) b[i] = (uint8_t)rnd();
if (f == VK_FORMAT_BC7_UNORM_BLOCK) {
int m = mode % 8;
b[0] = (uint8_t)((b[0] & ~((1u << (m + 1)) - 1)) | (1u << m));
} else if (f == VK_FORMAT_BC6H_UFLOAT_BLOCK || f == VK_FORMAT_BC6H_SFLOAT_BLOCK) {
static const uint8_t codes[14] = {0, 1, 2, 6, 10, 14, 18, 22, 26, 30, 3, 7, 11, 15};
int c = codes[mode % 14];
if (c < 2) b[0] = (uint8_t)((b[0] & ~3u) | c);
else b[0] = (uint8_t)((b[0] & ~31u) | c);
}
}
static float h2f(uint16_t h)
{
uint32_t s = (h >> 15) & 1, e = (h >> 10) & 31, m = h & 1023;
float v;
if (e == 0) v = ldexpf((float)m, -24);
else if (e == 31) v = m ? NAN : INFINITY;
else v = ldexpf((float)(m | 1024), (int)e - 25);
return s ? -v : v;
}
/* Reference texel (RGBA float) at (x, y) of the texture made from `blocks`. */
static void reference(VkFormat f, const uint8_t *blocks, int bytes, int x, int y, float out[4])
{
const uint8_t *b = blocks + ((y / 4) * (TEX / 4) + (x / 4)) * bytes;
int tx = x & 3, ty = y & 3;
uint8_t px8[16 * 4];
int8_t spx[16 * 2];
uint16_t px16[16 * 3];
out[0] = out[1] = out[2] = 0;
out[3] = 1;
switch (f) {
case VK_FORMAT_BC1_RGBA_UNORM_BLOCK: bcdec_bc1(b, px8, 16); break;
case VK_FORMAT_BC2_UNORM_BLOCK: bcdec_bc2(b, px8, 16); break;
case VK_FORMAT_BC3_UNORM_BLOCK: bcdec_bc3(b, px8, 16); break;
case VK_FORMAT_BC7_UNORM_BLOCK: bcdec_bc7(b, px8, 16); break;
case VK_FORMAT_BC4_UNORM_BLOCK: bcdec_bc4(b, px8, 4, 0); out[0] = px8[ty * 4 + tx] / 255.0f; return;
case VK_FORMAT_BC4_SNORM_BLOCK: bcdec_bc4(b, spx, 4, 1); out[0] = fmaxf(spx[ty * 4 + tx] / 127.0f, -1.0f); return;
case VK_FORMAT_BC5_UNORM_BLOCK:
bcdec_bc5(b, px8, 8, 0);
out[0] = px8[(ty * 4 + tx) * 2] / 255.0f;
out[1] = px8[(ty * 4 + tx) * 2 + 1] / 255.0f;
return;
case VK_FORMAT_BC5_SNORM_BLOCK:
bcdec_bc5(b, spx, 8, 1);
out[0] = fmaxf(spx[(ty * 4 + tx) * 2] / 127.0f, -1.0f);
out[1] = fmaxf(spx[(ty * 4 + tx) * 2 + 1] / 127.0f, -1.0f);
return;
case VK_FORMAT_BC6H_UFLOAT_BLOCK:
case VK_FORMAT_BC6H_SFLOAT_BLOCK:
bcdec_bc6h_half(b, px16, 12, f == VK_FORMAT_BC6H_SFLOAT_BLOCK);
for (int c = 0; c < 3; c++) out[c] = h2f(px16[(ty * 4 + tx) * 3 + c]);
return;
default: return;
}
for (int c = 0; c < 4; c++) out[c] = px8[(ty * 4 + tx) * 4 + c] / 255.0f;
}
static VkCommandBuffer begin(void)
{
VkCommandBufferAllocateInfo ai = {VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO, NULL, pool, VK_COMMAND_BUFFER_LEVEL_PRIMARY, 1};
VkCommandBuffer cb;
vkAllocateCommandBuffers(dev, &ai, &cb);
VkCommandBufferBeginInfo bi = {VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, NULL, VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT, NULL};
vkBeginCommandBuffer(cb, &bi);
return cb;
}
static void barrier(VkCommandBuffer cb, VkImage img, VkImageLayout from, VkImageLayout to)
{
VkImageMemoryBarrier b = {VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, NULL, VK_ACCESS_MEMORY_WRITE_BIT,
VK_ACCESS_MEMORY_READ_BIT | VK_ACCESS_MEMORY_WRITE_BIT, from, to, VK_QUEUE_FAMILY_IGNORED,
VK_QUEUE_FAMILY_IGNORED, img, {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1}};
vkCmdPipelineBarrier(cb, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, 0, 0, NULL, 0, NULL, 1, &b);
}
static int failures;
static void test_format(VkFormat f, const char *name, float tol)
{
int bytes = (f == VK_FORMAT_BC1_RGBA_UNORM_BLOCK || f == VK_FORMAT_BC4_UNORM_BLOCK || f == VK_FORMAT_BC4_SNORM_BLOCK) ? 8 : 16;
int nblocks = (TEX / 4) * (TEX / 4);
uint8_t *blocks = malloc((size_t)nblocks * bytes);
for (int i = 0; i < nblocks; i++) make_block(f, blocks + i * bytes, bytes, i);
VkFormatProperties fp;
vkGetPhysicalDeviceFormatProperties(pd, f, &fp);
if (!(fp.optimalTilingFeatures & VK_FORMAT_FEATURE_BLIT_SRC_BIT)) {
printf("SKIP %s: no blit from this format\n", name);
free(blocks);
return;
}
/* staging */
VkBufferCreateInfo bci = {VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, NULL, 0, (VkDeviceSize)TEX * TEX * 16,
VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT, VK_SHARING_MODE_EXCLUSIVE, 0, NULL};
VkBuffer up, down;
vkCreateBuffer(dev, &bci, NULL, &up);
vkCreateBuffer(dev, &bci, NULL, &down);
VkMemoryRequirements r;
vkGetBufferMemoryRequirements(dev, up, &r);
VkDeviceMemory upm = bind_mem(r, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT);
vkBindBufferMemory(dev, up, upm, 0);
vkGetBufferMemoryRequirements(dev, down, &r);
VkDeviceMemory downm = bind_mem(r, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT);
vkBindBufferMemory(dev, down, downm, 0);
void *upp, *downp;
vkMapMemory(dev, upm, 0, VK_WHOLE_SIZE, 0, &upp);
vkMapMemory(dev, downm, 0, VK_WHOLE_SIZE, 0, &downp);
/* upload at an odd 16-byte offset with a padded row, to exercise the decoder's addressing */
const VkDeviceSize off = 48;
const uint32_t row_tex = TEX + 8;
memset(upp, 0xcd, (size_t)TEX * TEX * 16);
for (int by = 0; by < TEX / 4; by++)
memcpy((uint8_t *)upp + off + (size_t)by * (row_tex / 4) * bytes, blocks + (size_t)by * (TEX / 4) * bytes, (size_t)(TEX / 4) * bytes);
/* images */
VkImageCreateInfo ici = {VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, NULL, 0, VK_IMAGE_TYPE_2D, f, {TEX, TEX, 1}, 1, 1, VK_SAMPLE_COUNT_1_BIT,
VK_IMAGE_TILING_OPTIMAL, VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_SAMPLED_BIT,
VK_SHARING_MODE_EXCLUSIVE, 0, NULL, VK_IMAGE_LAYOUT_UNDEFINED};
VkImage bc, rgba;
if (vkCreateImage(dev, &ici, NULL, &bc) != VK_SUCCESS) {
printf("FAIL %s: cannot create the image\n", name);
failures++;
return;
}
VkMemoryRequirements ir;
vkGetImageMemoryRequirements(dev, bc, &ir);
VkDeviceMemory bcm = bind_mem(ir, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
vkBindImageMemory(dev, bc, bcm, 0);
ici.format = VK_FORMAT_R32G32B32A32_SFLOAT;
vkCreateImage(dev, &ici, NULL, &rgba);
vkGetImageMemoryRequirements(dev, rgba, &ir);
VkDeviceMemory rgbam = bind_mem(ir, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
vkBindImageMemory(dev, rgba, rgbam, 0);
VkCommandBuffer cb = begin();
barrier(cb, bc, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
VkBufferImageCopy c = {off, row_tex, 0, {VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1}, {0, 0, 0}, {TEX, TEX, 1}};
vkCmdCopyBufferToImage(cb, up, bc, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &c);
barrier(cb, bc, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL);
barrier(cb, rgba, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
VkImageBlit bl = {{VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1}, {{0, 0, 0}, {TEX, TEX, 1}}, {VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1}, {{0, 0, 0}, {TEX, TEX, 1}}};
vkCmdBlitImage(cb, bc, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, rgba, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &bl, VK_FILTER_NEAREST);
barrier(cb, rgba, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL);
VkBufferImageCopy rb = {0, 0, 0, {VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1}, {0, 0, 0}, {TEX, TEX, 1}};
vkCmdCopyImageToBuffer(cb, rgba, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, down, 1, &rb);
VkMemoryBarrier mb = {VK_STRUCTURE_TYPE_MEMORY_BARRIER, NULL, VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_HOST_READ_BIT};
vkCmdPipelineBarrier(cb, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_HOST_BIT, 0, 1, &mb, 0, NULL, 0, NULL);
vkEndCommandBuffer(cb);
VkSubmitInfo si = {VK_STRUCTURE_TYPE_SUBMIT_INFO, NULL, 0, NULL, NULL, 1, &cb, 0, NULL};
vkQueueSubmit(queue, 1, &si, VK_NULL_HANDLE);
vkQueueWaitIdle(queue);
const float *got = downp;
int bad = 0, nan_skip = 0;
float worst = 0;
int wx = 0, wy = 0, wc = 0;
for (int y = 0; y < TEX; y++)
for (int x = 0; x < TEX; x++) {
float want[4];
reference(f, blocks, bytes, x, y, want);
for (int ch = 0; ch < 4; ch++) {
float g = got[(y * TEX + x) * 4 + ch], w = want[ch];
if (isnan(w) || isinf(w)) {
nan_skip++;
continue;
}
float d = fabsf(g - w);
float lim = (f == VK_FORMAT_BC6H_UFLOAT_BLOCK || f == VK_FORMAT_BC6H_SFLOAT_BLOCK) ? tol * fmaxf(1.0f, fabsf(w)) : tol;
if (!(d <= lim)) {
bad++;
if (!(d <= worst)) {
worst = d;
wx = x;
wy = y;
wc = ch;
}
}
}
}
if (bad) {
float want[4];
reference(f, blocks, bytes, wx, wy, want);
printf("FAIL %s: %d of %d values differ from bcdec; worst %.4f at (%d,%d) ch %d: got %g want %g (block mode byte 0x%02x)\n", name, bad,
TEX * TEX * 4, worst, wx, wy, wc, got[(wy * TEX + wx) * 4 + wc], want[wc],
blocks[((wy / 4) * (TEX / 4) + (wx / 4)) * bytes]);
failures++;
} else {
printf("PASS %s: %d texels match bcdec%s\n", name, TEX * TEX, nan_skip ? " (inf/nan references skipped)" : "");
}
vkDestroyImage(dev, bc, NULL);
vkDestroyImage(dev, rgba, NULL);
vkDestroyBuffer(dev, up, NULL);
vkDestroyBuffer(dev, down, NULL);
vkFreeMemory(dev, upm, NULL);
vkFreeMemory(dev, downm, NULL);
vkFreeMemory(dev, bcm, NULL);
vkFreeMemory(dev, rgbam, NULL);
free(blocks);
}
int main(int argc, char **argv)
{
int gpu = argc > 1 ? atoi(argv[1]) : 0;
void *lib = dlopen("libvulkan.so.1", RTLD_NOW);
gipa = (PFN_vkGetInstanceProcAddr)dlsym(lib, "vkGetInstanceProcAddr");
#define G(n) n = (PFN_##n)gipa(inst, #n)
G(vkCreateInstance);
VkApplicationInfo app = {VK_STRUCTURE_TYPE_APPLICATION_INFO, NULL, "bcn_check", 1, NULL, 0, VK_API_VERSION_1_1};
VkInstanceCreateInfo ici = {VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO, NULL, 0, &app, 0, NULL, 0, NULL};
if (vkCreateInstance(&ici, NULL, &inst)) return 2;
G(vkEnumeratePhysicalDevices); G(vkGetPhysicalDeviceMemoryProperties); G(vkCreateDevice); G(vkGetDeviceProcAddr);
G(vkGetPhysicalDeviceFeatures); G(vkGetPhysicalDeviceFormatProperties); G(vkGetPhysicalDeviceProperties);
uint32_t n = 8;
VkPhysicalDevice pds[8];
vkEnumeratePhysicalDevices(inst, &n, pds);
pd = pds[gpu];
VkPhysicalDeviceProperties props;
vkGetPhysicalDeviceProperties(pd, &props);
VkPhysicalDeviceFeatures feats;
vkGetPhysicalDeviceFeatures(pd, &feats);
printf("%s, textureCompressionBC=%u\n", props.deviceName, feats.textureCompressionBC);
if (!feats.textureCompressionBC) return 1;
vkGetPhysicalDeviceMemoryProperties(pd, &mp);
float prio = 1;
VkDeviceQueueCreateInfo qci = {VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO, NULL, 0, 0, 1, &prio};
VkPhysicalDeviceFeatures en = {0};
en.textureCompressionBC = VK_TRUE;
VkDeviceCreateInfo dci = {VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO, NULL, 0, 1, &qci, 0, NULL, 0, NULL, &en};
if (vkCreateDevice(pd, &dci, NULL, &dev)) return 2;
#undef G
#define G(n) n = (PFN_##n)vkGetDeviceProcAddr(dev, #n)
G(vkGetDeviceQueue); G(vkCreateCommandPool); G(vkAllocateCommandBuffers); G(vkBeginCommandBuffer); G(vkEndCommandBuffer);
G(vkQueueSubmit); G(vkQueueWaitIdle); G(vkCreateBuffer); G(vkGetBufferMemoryRequirements); G(vkAllocateMemory);
G(vkBindBufferMemory); G(vkMapMemory); G(vkCreateImage); G(vkGetImageMemoryRequirements); G(vkBindImageMemory);
G(vkCmdPipelineBarrier); G(vkCmdCopyBufferToImage); G(vkCmdBlitImage); G(vkCmdCopyImageToBuffer); G(vkDestroyImage);
G(vkDestroyBuffer); G(vkFreeMemory);
#undef G
vkGetDeviceQueue(dev, 0, 0, &queue);
VkCommandPoolCreateInfo pci = {VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO, NULL, 0, 0};
vkCreateCommandPool(dev, &pci, NULL, &pool);
float u8 = 2.5f / 255.0f; /* hardware decoders round differently from bcdec by up to 2 */
test_format(VK_FORMAT_BC1_RGBA_UNORM_BLOCK, "BC1", u8);
test_format(VK_FORMAT_BC2_UNORM_BLOCK, "BC2", u8);
test_format(VK_FORMAT_BC3_UNORM_BLOCK, "BC3", u8);
test_format(VK_FORMAT_BC4_UNORM_BLOCK, "BC4 unorm", u8);
test_format(VK_FORMAT_BC4_SNORM_BLOCK, "BC4 snorm", 2.5f / 127.0f);
test_format(VK_FORMAT_BC5_UNORM_BLOCK, "BC5 unorm", u8);
test_format(VK_FORMAT_BC5_SNORM_BLOCK, "BC5 snorm", 2.5f / 127.0f);
test_format(VK_FORMAT_BC6H_UFLOAT_BLOCK, "BC6H ufloat (all 14 modes)", 0.002f);
test_format(VK_FORMAT_BC6H_SFLOAT_BLOCK, "BC6H sfloat (all 14 modes)", 0.002f);
test_format(VK_FORMAT_BC7_UNORM_BLOCK, "BC7 (all 8 modes)", u8);
printf("%s\n", failures ? "FAILED" : "OK");
return failures ? 1 : 0;
}
+116
View File
@@ -0,0 +1,116 @@
/* SPDX-License-Identifier: GPL-3.0-or-later
*
* d3d11_bench.exe [draws] [frames]: a game-like D3D11 frame - many small draws, each with a
* Map(WRITE_DISCARD) constant buffer update and its own texture/sampler binding - rendered
* offscreen and flushed every frame (with a readback every 30th, so the GPU cannot fall behind).
* Prints milliseconds per frame: the bridge's overhead shows as the difference to native.
*/
#define COBJMACROS
#include <windows.h>
#include <d3d11.h>
#include <d3dcompiler.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main(int argc, char **argv)
{
int draws = argc > 1 ? atoi(argv[1]) : 1000;
int frames = argc > 2 ? atoi(argv[2]) : 300;
ID3D11Device *dev;
ID3D11DeviceContext *ctx;
D3D_FEATURE_LEVEL fl = D3D_FEATURE_LEVEL_11_0;
if (FAILED(D3D11CreateDevice(NULL, D3D_DRIVER_TYPE_HARDWARE, NULL, 0, &fl, 1, D3D11_SDK_VERSION, &dev, NULL, &ctx))) {
printf("no device\n");
return 1;
}
const char *vs = "cbuffer C : register(b0) { float4 pos; float4 col; };"
"struct O { float4 p : SV_Position; float4 c : COLOR; float2 uv : TEXCOORD; };"
"O main(uint id : SV_VertexID) { O o; float2 t = float2((id << 1) & 2, id & 2) * 0.05;"
"o.p = float4(pos.xy + t, 0, 1); o.c = col; o.uv = t * 20; return o; }";
const char *ps = "Texture2D t : register(t0); SamplerState s : register(s0);"
"float4 main(float4 p : SV_Position, float4 c : COLOR, float2 uv : TEXCOORD) : SV_Target { return c * t.Sample(s, uv); }";
ID3DBlob *vb, *pb;
D3DCompile(vs, strlen(vs), NULL, NULL, NULL, "main", "vs_5_0", 0, 0, &vb, NULL);
D3DCompile(ps, strlen(ps), NULL, NULL, NULL, "main", "ps_5_0", 0, 0, &pb, NULL);
ID3D11VertexShader *vsh;
ID3D11PixelShader *psh;
ID3D11Device_CreateVertexShader(dev, ID3D10Blob_GetBufferPointer(vb), ID3D10Blob_GetBufferSize(vb), NULL, &vsh);
ID3D11Device_CreatePixelShader(dev, ID3D10Blob_GetBufferPointer(pb), ID3D10Blob_GetBufferSize(pb), NULL, &psh);
D3D11_BUFFER_DESC bd = {32, D3D11_USAGE_DYNAMIC, D3D11_BIND_CONSTANT_BUFFER, D3D11_CPU_ACCESS_WRITE, 0, 0};
ID3D11Buffer *cb;
ID3D11Device_CreateBuffer(dev, &bd, NULL, &cb);
/* 8 small BC1 textures (block-compressed like a game's) */
ID3D11ShaderResourceView *srv[8];
uint8_t blocks[16 * 8];
for (int i = 0; i < (int)sizeof(blocks); i++) blocks[i] = (uint8_t)(i * 37 + 11);
for (int i = 0; i < 8; i++) {
D3D11_TEXTURE2D_DESC td = {16, 16, 1, 1, DXGI_FORMAT_BC1_UNORM, {1, 0}, D3D11_USAGE_DEFAULT, D3D11_BIND_SHADER_RESOURCE, 0, 0};
D3D11_SUBRESOURCE_DATA init = {blocks, 32, 0};
ID3D11Texture2D *t;
ID3D11Device_CreateTexture2D(dev, &td, &init, &t);
ID3D11Device_CreateShaderResourceView(dev, (ID3D11Resource *)t, NULL, &srv[i]);
}
D3D11_SAMPLER_DESC sd = {D3D11_FILTER_MIN_MAG_MIP_LINEAR, D3D11_TEXTURE_ADDRESS_WRAP, D3D11_TEXTURE_ADDRESS_WRAP, D3D11_TEXTURE_ADDRESS_WRAP,
0, 1, D3D11_COMPARISON_NEVER, {0}, 0, D3D11_FLOAT32_MAX};
ID3D11SamplerState *smp;
ID3D11Device_CreateSamplerState(dev, &sd, &smp);
D3D11_TEXTURE2D_DESC rd = {1280, 720, 1, 1, DXGI_FORMAT_R8G8B8A8_UNORM, {1, 0}, D3D11_USAGE_DEFAULT, D3D11_BIND_RENDER_TARGET, 0, 0};
ID3D11Texture2D *rt, *st;
ID3D11Device_CreateTexture2D(dev, &rd, NULL, &rt);
rd.Usage = D3D11_USAGE_STAGING;
rd.BindFlags = 0;
rd.CPUAccessFlags = D3D11_CPU_ACCESS_READ;
rd.Width = rd.Height = 16;
ID3D11Device_CreateTexture2D(dev, &rd, NULL, &st);
ID3D11RenderTargetView *rtv;
ID3D11Device_CreateRenderTargetView(dev, (ID3D11Resource *)rt, NULL, &rtv);
D3D11_VIEWPORT vp = {0, 0, 1280, 720, 0, 1};
LARGE_INTEGER f, t0, t1;
QueryPerformanceFrequency(&f);
double total = 0, worst = 0;
for (int fr = 0; fr < frames + 10; fr++) {
QueryPerformanceCounter(&t0);
float clear[4] = {0.1f, 0.1f, 0.1f, 1};
ID3D11DeviceContext_OMSetRenderTargets(ctx, 1, &rtv, NULL);
ID3D11DeviceContext_RSSetViewports(ctx, 1, &vp);
ID3D11DeviceContext_ClearRenderTargetView(ctx, rtv, clear);
ID3D11DeviceContext_IASetPrimitiveTopology(ctx, D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
ID3D11DeviceContext_VSSetShader(ctx, vsh, NULL, 0);
ID3D11DeviceContext_PSSetShader(ctx, psh, NULL, 0);
ID3D11DeviceContext_VSSetConstantBuffers(ctx, 0, 1, &cb);
ID3D11DeviceContext_PSSetSamplers(ctx, 0, 1, &smp);
for (int d = 0; d < draws; d++) {
D3D11_MAPPED_SUBRESOURCE m;
ID3D11DeviceContext_Map(ctx, (ID3D11Resource *)cb, 0, D3D11_MAP_WRITE_DISCARD, 0, &m);
float *p = m.pData;
p[0] = -1 + 2.0f * (d % 40) / 40;
p[1] = -1 + 2.0f * ((d / 40) % 40) / 40;
p[4] = (d & 1) ? 1.0f : 0.5f;
p[5] = (d & 2) ? 1.0f : 0.5f;
p[6] = (d & 4) ? 1.0f : 0.5f;
p[7] = 1;
ID3D11DeviceContext_Unmap(ctx, (ID3D11Resource *)cb, 0);
ID3D11DeviceContext_PSSetShaderResources(ctx, 0, 1, &srv[d & 7]);
ID3D11DeviceContext_Draw(ctx, 3, 0);
}
if (fr % 30 == 29) {
D3D11_BOX box = {0, 0, 0, 16, 16, 1};
ID3D11DeviceContext_CopySubresourceRegion(ctx, (ID3D11Resource *)st, 0, 0, 0, 0, (ID3D11Resource *)rt, 0, &box);
D3D11_MAPPED_SUBRESOURCE m;
ID3D11DeviceContext_Map(ctx, (ID3D11Resource *)st, 0, D3D11_MAP_READ, 0, &m);
ID3D11DeviceContext_Unmap(ctx, (ID3D11Resource *)st, 0);
} else {
ID3D11DeviceContext_Flush(ctx);
}
QueryPerformanceCounter(&t1);
double ms = (double)(t1.QuadPart - t0.QuadPart) * 1000.0 / (double)f.QuadPart;
if (fr >= 10) {
total += ms;
if (ms > worst) worst = ms;
}
}
printf("%d draws/frame: %.2f ms/frame average (%.0f fps), worst %.2f ms\n", draws, total / frames, 1000.0 * frames / total, worst);
return 0;
}
+366
View File
@@ -0,0 +1,366 @@
/* 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;
}
+12
View File
@@ -0,0 +1,12 @@
#!/bin/bash
# Compiles the test shaders into C arrays (tests/smoke_spv.h). Needs glslangValidator.
set -eu
cd "$(dirname "$0")"
out=smoke_spv.h
echo "/* Generated by gen_shaders.sh from shaders/ - do not edit. */" > $out
for s in shaders/*.comp shaders/*.vert shaders/*.frag; do
name=$(basename "$s" | tr . _)
glslangValidator -V --vn "spv_$name" -o tmp.h "$s" >/dev/null
grep -v '^ *//' tmp.h | sed 's/^const uint32_t/static const uint32_t/' >> $out
rm -f tmp.h
done
+9
View File
@@ -0,0 +1,9 @@
#version 450
layout(local_size_x = 64) in;
layout(std430, binding = 0) readonly buffer In { uint v[]; } src;
layout(std430, binding = 1) writeonly buffer Out { uint v[]; } dst;
layout(push_constant) uniform PC { uint mul; uint add; } pc;
void main() {
uint i = gl_GlobalInvocationID.x;
dst.v[i] = src.v[i] * pc.mul + pc.add;
}
+4
View File
@@ -0,0 +1,4 @@
#version 450
layout(push_constant) uniform PC { vec4 color; } pc;
layout(location = 0) out vec4 o;
void main() { o = pc.color; }
+5
View File
@@ -0,0 +1,5 @@
#version 450
void main() {
vec2 p = vec2((gl_VertexIndex << 1) & 2, gl_VertexIndex & 2);
gl_Position = vec4(p * 2.0 - 1.0, 0.0, 1.0);
}
+513
View File
@@ -0,0 +1,513 @@
/* SPDX-License-Identifier: GPL-3.0-or-later
*
* droiddeck-vkbridge-smoke: a self-checking Vulkan test, run at session start (Mali bridge on)
* and on the host against the bridge. Every check compares real bytes; output goes to stdout
* one line per check, exit status 0 only if all pass.
*
* droiddeck-vkbridge-smoke [--gpu N] [--quiet]
*/
#define VK_NO_PROTOTYPES
#include <vulkan/vulkan.h>
#include <dlfcn.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include "smoke_spv.h"
static PFN_vkGetInstanceProcAddr gipa;
static VkInstance inst;
static VkPhysicalDevice pd;
static VkDevice dev;
static VkQueue queue;
static uint32_t qfam;
static VkCommandPool pool;
static VkPhysicalDeviceMemoryProperties mp;
static int failures, checks;
#define I(name) PFN_##name name
static I(vkCreateInstance); static I(vkEnumeratePhysicalDevices); static I(vkGetPhysicalDeviceProperties);
static I(vkGetPhysicalDeviceQueueFamilyProperties); static I(vkGetPhysicalDeviceMemoryProperties); static I(vkCreateDevice);
static I(vkGetDeviceProcAddr); static I(vkDestroyInstance); static I(vkGetPhysicalDeviceFeatures);
static I(vkGetDeviceQueue); static I(vkCreateCommandPool); static I(vkAllocateCommandBuffers); static I(vkBeginCommandBuffer);
static I(vkEndCommandBuffer); static I(vkQueueSubmit); static I(vkQueueWaitIdle); static I(vkCreateBuffer);
static I(vkGetBufferMemoryRequirements); static I(vkAllocateMemory); static I(vkBindBufferMemory); static I(vkMapMemory);
static I(vkCmdFillBuffer); static I(vkCmdCopyBuffer); static I(vkCmdUpdateBuffer); static I(vkCmdPipelineBarrier);
static I(vkCreateShaderModule); static I(vkCreateDescriptorSetLayout); static I(vkCreatePipelineLayout);
static I(vkCreateComputePipelines); static I(vkCreateDescriptorPool); static I(vkAllocateDescriptorSets);
static I(vkUpdateDescriptorSets); static I(vkCmdBindPipeline); static I(vkCmdBindDescriptorSets); static I(vkCmdPushConstants);
static I(vkCmdDispatch); static I(vkCreateImage); static I(vkGetImageMemoryRequirements); static I(vkBindImageMemory);
static I(vkCmdClearColorImage); static I(vkCmdCopyImageToBuffer); static I(vkCreateImageView); static I(vkCreateRenderPass);
static I(vkCreateFramebuffer); static I(vkCreateGraphicsPipelines); static I(vkCmdBeginRenderPass); static I(vkCmdEndRenderPass);
static I(vkCmdDraw); static I(vkCreateSemaphore); static I(vkSignalSemaphore); static I(vkWaitSemaphores);
static I(vkGetSemaphoreCounterValue); static I(vkDestroyDevice); static I(vkFlushMappedMemoryRanges);
static I(vkInvalidateMappedMemoryRanges); static I(vkCmdSetViewport); static I(vkCmdSetScissor);
static I(vkCreateFence); static I(vkWaitForFences); static I(vkCmdCopyBufferToImage);
#undef I
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 double now_ms(void)
{
struct timespec t;
clock_gettime(CLOCK_MONOTONIC, &t);
return t.tv_sec * 1e3 + t.tv_nsec / 1e6;
}
static uint32_t find_type(uint32_t bits, VkMemoryPropertyFlags want)
{
for (uint32_t i = 0; i < mp.memoryTypeCount; i++)
if ((bits & (1u << i)) && (mp.memoryTypes[i].propertyFlags & want) == want) return i;
return UINT32_MAX;
}
typedef struct {
VkBuffer buf;
VkDeviceMemory mem;
void *ptr;
VkMemoryPropertyFlags flags;
} buffer;
static int make_buffer(buffer *b, VkDeviceSize size, VkBufferUsageFlags usage, VkMemoryPropertyFlags want)
{
VkBufferCreateInfo ci = {VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, NULL, 0, size, usage, VK_SHARING_MODE_EXCLUSIVE, 0, NULL};
if (vkCreateBuffer(dev, &ci, NULL, &b->buf)) return 0;
VkMemoryRequirements r;
vkGetBufferMemoryRequirements(dev, b->buf, &r);
uint32_t t = find_type(r.memoryTypeBits, want);
if (t == UINT32_MAX) return 0;
b->flags = mp.memoryTypes[t].propertyFlags;
VkMemoryAllocateInfo ai = {VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO, NULL, r.size, t};
if (vkAllocateMemory(dev, &ai, NULL, &b->mem) || vkBindBufferMemory(dev, b->buf, b->mem, 0)) return 0;
b->ptr = NULL;
if (want & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) {
if (vkMapMemory(dev, b->mem, 0, VK_WHOLE_SIZE, 0, &b->ptr)) return 0;
}
return 1;
}
static void sync_to_gpu(buffer *b)
{
if (b->flags & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT) return;
VkMappedMemoryRange r = {VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE, NULL, b->mem, 0, VK_WHOLE_SIZE};
vkFlushMappedMemoryRanges(dev, 1, &r);
}
static void sync_from_gpu(buffer *b)
{
if (b->flags & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT) return;
VkMappedMemoryRange r = {VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE, NULL, b->mem, 0, VK_WHOLE_SIZE};
vkInvalidateMappedMemoryRanges(dev, 1, &r);
}
static VkCommandBuffer begin(void)
{
VkCommandBufferAllocateInfo ai = {VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO, NULL, pool, VK_COMMAND_BUFFER_LEVEL_PRIMARY, 1};
VkCommandBuffer cb;
vkAllocateCommandBuffers(dev, &ai, &cb);
VkCommandBufferBeginInfo bi = {VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, NULL, VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT, NULL};
vkBeginCommandBuffer(cb, &bi);
return cb;
}
static int submit(VkCommandBuffer cb)
{
VkMemoryBarrier mb = {VK_STRUCTURE_TYPE_MEMORY_BARRIER, NULL, VK_ACCESS_MEMORY_WRITE_BIT, VK_ACCESS_HOST_READ_BIT};
vkCmdPipelineBarrier(cb, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_HOST_BIT, 0, 1, &mb, 0, NULL, 0, NULL);
if (vkEndCommandBuffer(cb)) return 0;
VkFenceCreateInfo fci = {VK_STRUCTURE_TYPE_FENCE_CREATE_INFO};
VkFence f;
vkCreateFence(dev, &fci, NULL, &f);
VkSubmitInfo si = {VK_STRUCTURE_TYPE_SUBMIT_INFO, NULL, 0, NULL, NULL, 1, &cb, 0, NULL};
return !vkQueueSubmit(queue, 1, &si, f) && !vkWaitForFences(dev, 1, &f, VK_TRUE, 10000000000ull);
}
static VkShaderModule shader(const uint32_t *code, size_t size)
{
VkShaderModuleCreateInfo ci = {VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO, NULL, 0, size, code};
VkShaderModule m = VK_NULL_HANDLE;
vkCreateShaderModule(dev, &ci, NULL, &m);
return m;
}
/* ------------------------------------------------------------------ tests */
static void test_memory(void)
{
char d[160];
buffer b;
const uint32_t n = 1 << 16;
if (!make_buffer(&b, n * 4, VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT,
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT)) {
check(0, "host-visible buffer", "cannot create/map");
return;
}
uint32_t *p = b.ptr;
for (uint32_t i = 0; i < n; i++) p[i] = i ^ 0x5a5a0000u;
sync_to_gpu(&b);
VkCommandBuffer cb = begin();
vkCmdFillBuffer(cb, b.buf, 0, n, 0xC0FFEE00u); /* words [0, n/4) */
VkBufferCopy c = {n * 2, n * 3, n}; /* words [n/2, 3n/4) -> [3n/4, n) */
vkCmdCopyBuffer(cb, b.buf, b.buf, 1, &c);
uint32_t upd[16];
for (int i = 0; i < 16; i++) upd[i] = 0xABC00000u + (uint32_t)i;
vkCmdUpdateBuffer(cb, b.buf, n + 64, sizeof(upd), upd); /* words [n/4 + 16, +16) */
int ok = submit(cb);
sync_from_gpu(&b);
int bad = -1;
for (uint32_t i = 0; ok && i < n; i++) {
uint32_t want;
if (i < n / 4) want = 0xC0FFEE00u;
else if (i >= n / 4 + 16 && i < n / 4 + 32) want = 0xABC00000u + (i - n / 4 - 16);
else if (i >= 3 * n / 4) want = (i - n / 4) ^ 0x5a5a0000u;
else want = i ^ 0x5a5a0000u;
if (p[i] != want) {
bad = (int)i;
break;
}
}
snprintf(d, sizeof(d), bad < 0 ? "fill/copy/update seen through the mapping (memory flags 0x%x)" : "word %d wrong", bad < 0 ? (int)b.flags : bad);
check(ok && bad < 0, "mapped memory + transfer commands", d);
}
static void test_compute(void)
{
char d[160];
const uint32_t n = 4096;
buffer in, out;
if (!make_buffer(&in, n * 4, VK_BUFFER_USAGE_STORAGE_BUFFER_BIT, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) ||
!make_buffer(&out, n * 4, VK_BUFFER_USAGE_STORAGE_BUFFER_BIT, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT)) {
check(0, "compute", "buffers");
return;
}
for (uint32_t i = 0; i < n; i++) ((uint32_t *)in.ptr)[i] = i;
sync_to_gpu(&in);
VkDescriptorSetLayoutBinding binds[2] = {{0, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1, VK_SHADER_STAGE_COMPUTE_BIT, NULL},
{1, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1, VK_SHADER_STAGE_COMPUTE_BIT, NULL}};
VkDescriptorSetLayoutCreateInfo lci = {VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO, NULL, 0, 2, binds};
VkDescriptorSetLayout dsl;
vkCreateDescriptorSetLayout(dev, &lci, NULL, &dsl);
VkPushConstantRange pcr = {VK_SHADER_STAGE_COMPUTE_BIT, 0, 8};
VkPipelineLayoutCreateInfo plci = {VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, NULL, 0, 1, &dsl, 1, &pcr};
VkPipelineLayout pl;
vkCreatePipelineLayout(dev, &plci, NULL, &pl);
VkComputePipelineCreateInfo cpci = {VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO};
cpci.stage = (VkPipelineShaderStageCreateInfo){VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, NULL, 0, VK_SHADER_STAGE_COMPUTE_BIT,
shader(spv_smoke_comp, sizeof(spv_smoke_comp)), "main", NULL};
cpci.layout = pl;
VkPipeline pipe;
double t0 = now_ms();
VkResult r = vkCreateComputePipelines(dev, VK_NULL_HANDLE, 1, &cpci, NULL, &pipe);
if (r) {
check(0, "compute pipeline", "creation failed");
return;
}
VkDescriptorPoolSize ps = {VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 2};
VkDescriptorPoolCreateInfo dpci = {VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO, NULL, 0, 1, 1, &ps};
VkDescriptorPool dp;
vkCreateDescriptorPool(dev, &dpci, NULL, &dp);
VkDescriptorSetAllocateInfo dsai = {VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO, NULL, dp, 1, &dsl};
VkDescriptorSet set;
vkAllocateDescriptorSets(dev, &dsai, &set);
VkDescriptorBufferInfo bi[2] = {{in.buf, 0, VK_WHOLE_SIZE}, {out.buf, 0, VK_WHOLE_SIZE}};
VkWriteDescriptorSet w[2] = {{VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, NULL, set, 0, 0, 1, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, NULL, &bi[0], NULL},
{VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, NULL, set, 1, 0, 1, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, NULL, &bi[1], NULL}};
vkUpdateDescriptorSets(dev, 2, w, 0, NULL);
VkCommandBuffer cb = begin();
vkCmdBindPipeline(cb, VK_PIPELINE_BIND_POINT_COMPUTE, pipe);
vkCmdBindDescriptorSets(cb, VK_PIPELINE_BIND_POINT_COMPUTE, pl, 0, 1, &set, 0, NULL);
uint32_t pc[2] = {3, 7};
vkCmdPushConstants(cb, pl, VK_SHADER_STAGE_COMPUTE_BIT, 0, 8, pc);
vkCmdDispatch(cb, n / 64, 1, 1);
int ok = submit(cb);
sync_from_gpu(&out);
int bad = -1;
for (uint32_t i = 0; ok && i < n; i++)
if (((uint32_t *)out.ptr)[i] != i * 3 + 7) {
bad = (int)i;
break;
}
snprintf(d, sizeof(d), bad < 0 ? "%u invocations correct (%.1f ms incl. pipeline)" : "element %d wrong", bad < 0 ? n : (unsigned)bad,
now_ms() - t0);
check(ok && bad < 0, "compute shader", d);
}
static VkImage make_image(VkFormat fmt, uint32_t w, uint32_t h, VkImageUsageFlags usage)
{
VkImageCreateInfo ci = {VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, NULL, 0, VK_IMAGE_TYPE_2D, fmt, {w, h, 1}, 1, 1, VK_SAMPLE_COUNT_1_BIT,
VK_IMAGE_TILING_OPTIMAL, usage, VK_SHARING_MODE_EXCLUSIVE, 0, NULL, VK_IMAGE_LAYOUT_UNDEFINED};
VkImage img;
if (vkCreateImage(dev, &ci, NULL, &img)) return VK_NULL_HANDLE;
VkMemoryRequirements r;
vkGetImageMemoryRequirements(dev, img, &r);
uint32_t t = find_type(r.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
if (t == UINT32_MAX) t = find_type(r.memoryTypeBits, 0);
VkMemoryAllocateInfo ai = {VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO, NULL, r.size, t};
VkDeviceMemory m;
if (vkAllocateMemory(dev, &ai, NULL, &m) || vkBindImageMemory(dev, img, m, 0)) return VK_NULL_HANDLE;
return img;
}
static void barrier(VkCommandBuffer cb, VkImage img, VkImageLayout from, VkImageLayout to)
{
VkImageMemoryBarrier b = {VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, NULL, VK_ACCESS_MEMORY_WRITE_BIT,
VK_ACCESS_MEMORY_READ_BIT | VK_ACCESS_MEMORY_WRITE_BIT, from, to, VK_QUEUE_FAMILY_IGNORED,
VK_QUEUE_FAMILY_IGNORED, img, {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1}};
vkCmdPipelineBarrier(cb, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, 0, 0, NULL, 0, NULL, 1, &b);
}
static void test_image_clear(void)
{
const uint32_t w = 64, h = 64;
VkImage img = make_image(VK_FORMAT_R8G8B8A8_UNORM, w, h, VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT);
buffer rb;
if (!img || !make_buffer(&rb, w * h * 4, VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_TRANSFER_SRC_BIT,
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT)) {
check(0, "image clear + readback", "setup");
return;
}
VkCommandBuffer cb = begin();
barrier(cb, img, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
VkClearColorValue col = {.float32 = {1.0f, 0.5f, 0.0f, 1.0f}};
VkImageSubresourceRange rng = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1};
vkCmdClearColorImage(cb, img, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, &col, 1, &rng);
/* upload a 8x8 block from the buffer over the corner, to test buffer->image too */
for (int i = 0; i < 64; i++) ((uint32_t *)rb.ptr)[i] = 0xFF112233u;
sync_to_gpu(&rb);
VkBufferImageCopy up = {0, 8, 8, {VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1}, {0, 0, 0}, {8, 8, 1}};
vkCmdCopyBufferToImage(cb, rb.buf, img, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &up);
barrier(cb, img, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL);
VkBufferImageCopy c = {0, 0, 0, {VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1}, {0, 0, 0}, {w, h, 1}};
VkMemoryBarrier mb = {VK_STRUCTURE_TYPE_MEMORY_BARRIER, NULL, VK_ACCESS_TRANSFER_READ_BIT, VK_ACCESS_TRANSFER_WRITE_BIT};
vkCmdPipelineBarrier(cb, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 1, &mb, 0, NULL, 0, NULL);
vkCmdCopyImageToBuffer(cb, img, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, rb.buf, 1, &c);
int ok = submit(cb);
sync_from_gpu(&rb);
uint32_t *p = rb.ptr;
uint32_t want_clear = 0xFF0080FFu; /* R=255 G=128 B=0 A=255, little endian; 0.5 -> 127 or 128 */
int bad = -1;
for (uint32_t y = 0; ok && y < h; y++)
for (uint32_t x = 0; x < w; x++) {
uint32_t v = p[y * w + x];
int corner = x < 8 && y < 8;
int good = corner ? v == 0xFF112233u : ((v & 0xFFFF00FFu) == (want_clear & 0xFFFF00FFu) && ((v >> 8) & 0xFF) >= 127 && ((v >> 8) & 0xFF) <= 128);
if (!good && bad < 0) bad = (int)(y * w + x);
}
char d[128];
snprintf(d, sizeof(d), bad < 0 ? "64x64 RGBA8 clear, upload and readback exact" : "pixel %d = 0x%08x", bad, bad < 0 ? 0 : p[bad]);
check(ok && bad < 0, "image clear/upload/readback", d);
}
static void test_draw(void)
{
const uint32_t w = 128, h = 96;
VkFormat fmt = VK_FORMAT_B8G8R8A8_UNORM;
VkImage img = make_image(fmt, w, h, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT);
buffer rb;
if (!img || !make_buffer(&rb, w * h * 4, VK_BUFFER_USAGE_TRANSFER_DST_BIT, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT)) {
check(0, "draw", "setup");
return;
}
VkImageViewCreateInfo vci = {VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, NULL, 0, img, VK_IMAGE_VIEW_TYPE_2D, fmt, {0},
{VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1}};
VkImageView view;
vkCreateImageView(dev, &vci, NULL, &view);
VkAttachmentDescription att = {0, fmt, VK_SAMPLE_COUNT_1_BIT, VK_ATTACHMENT_LOAD_OP_CLEAR, VK_ATTACHMENT_STORE_OP_STORE,
VK_ATTACHMENT_LOAD_OP_DONT_CARE, VK_ATTACHMENT_STORE_OP_DONT_CARE, VK_IMAGE_LAYOUT_UNDEFINED,
VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL};
VkAttachmentReference ref = {0, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL};
VkSubpassDescription sub = {0, VK_PIPELINE_BIND_POINT_GRAPHICS, 0, NULL, 1, &ref, NULL, NULL, 0, NULL};
VkRenderPassCreateInfo rpci = {VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO, NULL, 0, 1, &att, 1, &sub, 0, NULL};
VkRenderPass rp;
vkCreateRenderPass(dev, &rpci, NULL, &rp);
VkFramebufferCreateInfo fci = {VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO, NULL, 0, rp, 1, &view, w, h, 1};
VkFramebuffer fb;
vkCreateFramebuffer(dev, &fci, NULL, &fb);
VkPushConstantRange pcr = {VK_SHADER_STAGE_FRAGMENT_BIT, 0, 16};
VkPipelineLayoutCreateInfo plci = {VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, NULL, 0, 0, NULL, 1, &pcr};
VkPipelineLayout pl;
vkCreatePipelineLayout(dev, &plci, NULL, &pl);
VkPipelineShaderStageCreateInfo st[2] = {
{VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, NULL, 0, VK_SHADER_STAGE_VERTEX_BIT, shader(spv_smoke_vert, sizeof(spv_smoke_vert)), "main", NULL},
{VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, NULL, 0, VK_SHADER_STAGE_FRAGMENT_BIT, shader(spv_smoke_frag, sizeof(spv_smoke_frag)), "main", NULL}};
VkPipelineVertexInputStateCreateInfo vi = {VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO};
VkPipelineInputAssemblyStateCreateInfo ia = {VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO, NULL, 0, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, 0};
VkPipelineViewportStateCreateInfo vp = {VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO, NULL, 0, 1, NULL, 1, NULL};
VkPipelineRasterizationStateCreateInfo rs = {VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO};
rs.polygonMode = VK_POLYGON_MODE_FILL;
rs.cullMode = VK_CULL_MODE_NONE;
rs.lineWidth = 1.0f;
VkPipelineMultisampleStateCreateInfo ms = {VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO, NULL, 0, VK_SAMPLE_COUNT_1_BIT};
VkPipelineColorBlendAttachmentState cba = {0};
cba.colorWriteMask = 0xF;
VkPipelineColorBlendStateCreateInfo cb_ = {VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO, NULL, 0, 0, 0, 1, &cba, {0}};
VkDynamicState dyn[2] = {VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR};
VkPipelineDynamicStateCreateInfo ds = {VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO, NULL, 0, 2, dyn};
VkGraphicsPipelineCreateInfo gpci = {VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO, NULL, 0, 2, st, &vi, &ia, NULL, &vp, &rs, &ms, NULL, &cb_, &ds,
pl, rp, 0, VK_NULL_HANDLE, -1};
VkPipeline pipe;
if (vkCreateGraphicsPipelines(dev, VK_NULL_HANDLE, 1, &gpci, NULL, &pipe)) {
check(0, "graphics pipeline", "creation failed");
return;
}
VkCommandBuffer cb = begin();
VkClearValue clear = {.color = {.float32 = {0, 0, 0, 1}}};
VkRenderPassBeginInfo rbi = {VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO, NULL, rp, fb, {{0, 0}, {w, h}}, 1, &clear};
vkCmdBeginRenderPass(cb, &rbi, VK_SUBPASS_CONTENTS_INLINE);
vkCmdBindPipeline(cb, VK_PIPELINE_BIND_POINT_GRAPHICS, pipe);
/* left half only: the right half keeps the clear colour */
VkViewport v = {0, 0, (float)w, (float)h, 0, 1};
VkRect2D sc = {{0, 0}, {w / 2, h}};
vkCmdSetViewport(cb, 0, 1, &v);
vkCmdSetScissor(cb, 0, 1, &sc);
float color[4] = {0.0f, 1.0f, 0.0f, 1.0f};
vkCmdPushConstants(cb, pl, VK_SHADER_STAGE_FRAGMENT_BIT, 0, 16, color);
vkCmdDraw(cb, 3, 1, 0, 0);
vkCmdEndRenderPass(cb);
VkBufferImageCopy c = {0, 0, 0, {VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1}, {0, 0, 0}, {w, h, 1}};
vkCmdCopyImageToBuffer(cb, img, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, rb.buf, 1, &c);
int ok = submit(cb);
sync_from_gpu(&rb);
uint32_t *p = rb.ptr;
int bad = -1;
for (uint32_t y = 0; ok && y < h; y++)
for (uint32_t x = 0; x < w; x++) {
uint32_t want = x < w / 2 ? 0xFF00FF00u : 0xFF000000u; /* BGRA: green / black */
if (p[y * w + x] != want && bad < 0) bad = (int)(y * w + x);
}
char d[128];
snprintf(d, sizeof(d), bad < 0 ? "render pass + pipeline + scissor exact (%ux%u)" : "pixel %d = 0x%08x", bad < 0 ? w : (unsigned)bad,
bad < 0 ? h : p[bad]);
check(ok && bad < 0, "draw", d);
}
static void test_timeline(void)
{
VkSemaphoreTypeCreateInfo t = {VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO, NULL, VK_SEMAPHORE_TYPE_TIMELINE, 5};
VkSemaphoreCreateInfo ci = {VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO, &t, 0};
VkSemaphore s;
if (!vkCreateSemaphore || vkCreateSemaphore(dev, &ci, NULL, &s) || !vkSignalSemaphore) {
check(1, "timeline semaphore", "skipped (Vulkan 1.2 not available)");
return;
}
VkSemaphoreSignalInfo si = {VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO, NULL, s, 9};
vkSignalSemaphore(dev, &si);
uint64_t v = 0;
vkGetSemaphoreCounterValue(dev, s, &v);
uint64_t want = 9;
VkSemaphoreWaitInfo wi = {VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO, NULL, 0, 1, &s, &want};
VkResult r = vkWaitSemaphores(dev, &wi, 1000000000ull);
char d[64];
snprintf(d, sizeof(d), "value %llu", (unsigned long long)v);
check(v == 9 && r == VK_SUCCESS, "timeline semaphore", d);
}
static void test_roundtrip_rate(void)
{
/* Bridge overhead: how many trivial synchronous calls per second. */
VkFenceCreateInfo fci = {VK_STRUCTURE_TYPE_FENCE_CREATE_INFO, NULL, VK_FENCE_CREATE_SIGNALED_BIT};
VkFence f;
vkCreateFence(dev, &fci, NULL, &f);
PFN_vkGetFenceStatus gfs = (PFN_vkGetFenceStatus)vkGetDeviceProcAddr(dev, "vkGetFenceStatus");
double t0 = now_ms();
int n = 2000;
for (int i = 0; i < n; i++) gfs(dev, f);
double us = (now_ms() - t0) * 1000.0 / n;
char d[64];
snprintf(d, sizeof(d), "%.1f us per synchronous call", us);
check(1, "call latency", d);
}
int main(int argc, char **argv)
{
int gpu = 0;
for (int i = 1; i < argc; i++)
if (!strcmp(argv[i], "--gpu") && i + 1 < argc) gpu = atoi(argv[++i]);
void *lib = dlopen("libvulkan.so.1", RTLD_NOW);
if (!lib) {
printf("FAIL loader: %s\n", dlerror());
return 2;
}
gipa = (PFN_vkGetInstanceProcAddr)dlsym(lib, "vkGetInstanceProcAddr");
#define G(n) n = (PFN_##n)gipa(inst, #n)
G(vkCreateInstance);
VkApplicationInfo app = {VK_STRUCTURE_TYPE_APPLICATION_INFO, NULL, "vkbridge-smoke", 1, "vkbridge", 1, VK_API_VERSION_1_2};
VkInstanceCreateInfo ici = {VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO, NULL, 0, &app, 0, NULL, 0, NULL};
VkResult r = vkCreateInstance(&ici, NULL, &inst);
check(r == VK_SUCCESS, "instance", r ? "vkCreateInstance failed" : "");
if (r) return 1;
G(vkEnumeratePhysicalDevices); G(vkGetPhysicalDeviceProperties); G(vkGetPhysicalDeviceQueueFamilyProperties);
G(vkGetPhysicalDeviceMemoryProperties); G(vkCreateDevice); G(vkGetDeviceProcAddr); G(vkDestroyInstance);
G(vkGetPhysicalDeviceFeatures);
uint32_t n = 0;
vkEnumeratePhysicalDevices(inst, &n, NULL);
VkPhysicalDevice pds[8];
if (n > 8) n = 8;
vkEnumeratePhysicalDevices(inst, &n, pds);
if ((uint32_t)gpu >= n) {
check(0, "physical device", "none");
return 1;
}
pd = pds[gpu];
VkPhysicalDeviceProperties props;
vkGetPhysicalDeviceProperties(pd, &props);
char d[300];
snprintf(d, sizeof(d), "%s, Vulkan %u.%u.%u", props.deviceName, VK_API_VERSION_MAJOR(props.apiVersion),
VK_API_VERSION_MINOR(props.apiVersion), VK_API_VERSION_PATCH(props.apiVersion));
check(1, "physical device", d);
vkGetPhysicalDeviceMemoryProperties(pd, &mp);
for (uint32_t i = 0; i < mp.memoryTypeCount; i++)
printf(" memory type %u: heap %u flags 0x%x\n", i, mp.memoryTypes[i].heapIndex, mp.memoryTypes[i].propertyFlags);
uint32_t nq = 0;
vkGetPhysicalDeviceQueueFamilyProperties(pd, &nq, NULL);
VkQueueFamilyProperties qp[16];
if (nq > 16) nq = 16;
vkGetPhysicalDeviceQueueFamilyProperties(pd, &nq, qp);
for (qfam = 0; qfam < nq; qfam++)
if (qp[qfam].queueFlags & VK_QUEUE_GRAPHICS_BIT) break;
float prio = 1.0f;
VkDeviceQueueCreateInfo qci = {VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO, NULL, 0, qfam, 1, &prio};
VkPhysicalDeviceVulkan12Features f12 = {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES};
f12.timelineSemaphore = VK_TRUE;
VkDeviceCreateInfo dci = {VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO, props.apiVersion >= VK_API_VERSION_1_2 ? &f12 : NULL, 0, 1, &qci, 0, NULL, 0, NULL, NULL};
r = vkCreateDevice(pd, &dci, NULL, &dev);
check(r == VK_SUCCESS, "device", r ? "vkCreateDevice failed" : "");
if (r) return 1;
#undef G
#define G(n) n = (PFN_##n)vkGetDeviceProcAddr(dev, #n)
G(vkGetDeviceQueue); G(vkCreateCommandPool); G(vkAllocateCommandBuffers); G(vkBeginCommandBuffer); G(vkEndCommandBuffer);
G(vkQueueSubmit); G(vkQueueWaitIdle); G(vkCreateBuffer); G(vkGetBufferMemoryRequirements); G(vkAllocateMemory);
G(vkBindBufferMemory); G(vkMapMemory); G(vkCmdFillBuffer); G(vkCmdCopyBuffer); G(vkCmdUpdateBuffer); G(vkCmdPipelineBarrier);
G(vkCreateShaderModule); G(vkCreateDescriptorSetLayout); G(vkCreatePipelineLayout); G(vkCreateComputePipelines);
G(vkCreateDescriptorPool); G(vkAllocateDescriptorSets); G(vkUpdateDescriptorSets); G(vkCmdBindPipeline);
G(vkCmdBindDescriptorSets); G(vkCmdPushConstants); G(vkCmdDispatch); G(vkCreateImage); G(vkGetImageMemoryRequirements);
G(vkBindImageMemory); G(vkCmdClearColorImage); G(vkCmdCopyImageToBuffer); G(vkCreateImageView); G(vkCreateRenderPass);
G(vkCreateFramebuffer); G(vkCreateGraphicsPipelines); G(vkCmdBeginRenderPass); G(vkCmdEndRenderPass); G(vkCmdDraw);
G(vkCreateSemaphore); G(vkSignalSemaphore); G(vkWaitSemaphores); G(vkGetSemaphoreCounterValue); G(vkDestroyDevice);
G(vkFlushMappedMemoryRanges); G(vkInvalidateMappedMemoryRanges); G(vkCmdSetViewport); G(vkCmdSetScissor);
G(vkCreateFence); G(vkWaitForFences); G(vkCmdCopyBufferToImage);
#undef G
vkGetDeviceQueue(dev, qfam, 0, &queue);
VkCommandPoolCreateInfo pci = {VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO, NULL, 0, qfam};
vkCreateCommandPool(dev, &pci, NULL, &pool);
test_memory();
test_compute();
test_image_clear();
test_draw();
test_timeline();
test_roundtrip_rate();
vkDestroyDevice(dev, NULL);
vkDestroyInstance(inst, NULL);
printf("%s: %d of %d checks passed\n", failures ? "FAILED" : "OK", checks - failures, checks);
return failures ? 1 : 0;
}
+108
View File
@@ -0,0 +1,108 @@
/* Generated by gen_shaders.sh from shaders/ - do not edit. */
// 1115.1.0
#pragma once
static const uint32_t spv_smoke_comp[] = {
0x07230203,0x00010000,0x0008000b,0x0000002e,0x00000000,0x00020011,0x00000001,0x0006000b,
0x00000001,0x4c534c47,0x6474732e,0x3035342e,0x00000000,0x0003000e,0x00000000,0x00000001,
0x0006000f,0x00000005,0x00000004,0x6e69616d,0x00000000,0x0000000b,0x00060010,0x00000004,
0x00000011,0x00000040,0x00000001,0x00000001,0x00030003,0x00000002,0x000001c2,0x00040005,
0x00000004,0x6e69616d,0x00000000,0x00030005,0x00000008,0x00000069,0x00080005,0x0000000b,
0x475f6c67,0x61626f6c,0x766e496c,0x7461636f,0x496e6f69,0x00000044,0x00030005,0x00000011,
0x0074754f,0x00040006,0x00000011,0x00000000,0x00000076,0x00030005,0x00000013,0x00747364,
0x00030005,0x00000018,0x00006e49,0x00040006,0x00000018,0x00000000,0x00000076,0x00030005,
0x0000001a,0x00637273,0x00030005,0x0000001f,0x00004350,0x00040006,0x0000001f,0x00000000,
0x006c756d,0x00040006,0x0000001f,0x00000001,0x00646461,0x00030005,0x00000021,0x00006370,
0x00040047,0x0000000b,0x0000000b,0x0000001c,0x00040047,0x00000010,0x00000006,0x00000004,
0x00030047,0x00000011,0x00000003,0x00040048,0x00000011,0x00000000,0x00000019,0x00050048,
0x00000011,0x00000000,0x00000023,0x00000000,0x00030047,0x00000013,0x00000019,0x00040047,
0x00000013,0x00000021,0x00000001,0x00040047,0x00000013,0x00000022,0x00000000,0x00040047,
0x00000017,0x00000006,0x00000004,0x00030047,0x00000018,0x00000003,0x00040048,0x00000018,
0x00000000,0x00000018,0x00050048,0x00000018,0x00000000,0x00000023,0x00000000,0x00030047,
0x0000001a,0x00000018,0x00040047,0x0000001a,0x00000021,0x00000000,0x00040047,0x0000001a,
0x00000022,0x00000000,0x00030047,0x0000001f,0x00000002,0x00050048,0x0000001f,0x00000000,
0x00000023,0x00000000,0x00050048,0x0000001f,0x00000001,0x00000023,0x00000004,0x00040047,
0x0000002d,0x0000000b,0x00000019,0x00020013,0x00000002,0x00030021,0x00000003,0x00000002,
0x00040015,0x00000006,0x00000020,0x00000000,0x00040020,0x00000007,0x00000007,0x00000006,
0x00040017,0x00000009,0x00000006,0x00000003,0x00040020,0x0000000a,0x00000001,0x00000009,
0x0004003b,0x0000000a,0x0000000b,0x00000001,0x0004002b,0x00000006,0x0000000c,0x00000000,
0x00040020,0x0000000d,0x00000001,0x00000006,0x0003001d,0x00000010,0x00000006,0x0003001e,
0x00000011,0x00000010,0x00040020,0x00000012,0x00000002,0x00000011,0x0004003b,0x00000012,
0x00000013,0x00000002,0x00040015,0x00000014,0x00000020,0x00000001,0x0004002b,0x00000014,
0x00000015,0x00000000,0x0003001d,0x00000017,0x00000006,0x0003001e,0x00000018,0x00000017,
0x00040020,0x00000019,0x00000002,0x00000018,0x0004003b,0x00000019,0x0000001a,0x00000002,
0x00040020,0x0000001c,0x00000002,0x00000006,0x0004001e,0x0000001f,0x00000006,0x00000006,
0x00040020,0x00000020,0x00000009,0x0000001f,0x0004003b,0x00000020,0x00000021,0x00000009,
0x00040020,0x00000022,0x00000009,0x00000006,0x0004002b,0x00000014,0x00000026,0x00000001,
0x0004002b,0x00000006,0x0000002b,0x00000040,0x0004002b,0x00000006,0x0000002c,0x00000001,
0x0006002c,0x00000009,0x0000002d,0x0000002b,0x0000002c,0x0000002c,0x00050036,0x00000002,
0x00000004,0x00000000,0x00000003,0x000200f8,0x00000005,0x0004003b,0x00000007,0x00000008,
0x00000007,0x00050041,0x0000000d,0x0000000e,0x0000000b,0x0000000c,0x0004003d,0x00000006,
0x0000000f,0x0000000e,0x0003003e,0x00000008,0x0000000f,0x0004003d,0x00000006,0x00000016,
0x00000008,0x0004003d,0x00000006,0x0000001b,0x00000008,0x00060041,0x0000001c,0x0000001d,
0x0000001a,0x00000015,0x0000001b,0x0004003d,0x00000006,0x0000001e,0x0000001d,0x00050041,
0x00000022,0x00000023,0x00000021,0x00000015,0x0004003d,0x00000006,0x00000024,0x00000023,
0x00050084,0x00000006,0x00000025,0x0000001e,0x00000024,0x00050041,0x00000022,0x00000027,
0x00000021,0x00000026,0x0004003d,0x00000006,0x00000028,0x00000027,0x00050080,0x00000006,
0x00000029,0x00000025,0x00000028,0x00060041,0x0000001c,0x0000002a,0x00000013,0x00000015,
0x00000016,0x0003003e,0x0000002a,0x00000029,0x000100fd,0x00010038
};
// 1115.1.0
#pragma once
static const uint32_t spv_smoke_vert[] = {
0x07230203,0x00010000,0x0008000b,0x0000002b,0x00000000,0x00020011,0x00000001,0x0006000b,
0x00000001,0x4c534c47,0x6474732e,0x3035342e,0x00000000,0x0003000e,0x00000000,0x00000001,
0x0007000f,0x00000000,0x00000004,0x6e69616d,0x00000000,0x0000000c,0x0000001d,0x00030003,
0x00000002,0x000001c2,0x00040005,0x00000004,0x6e69616d,0x00000000,0x00030005,0x00000009,
0x00000070,0x00060005,0x0000000c,0x565f6c67,0x65747265,0x646e4978,0x00007865,0x00060005,
0x0000001b,0x505f6c67,0x65567265,0x78657472,0x00000000,0x00060006,0x0000001b,0x00000000,
0x505f6c67,0x7469736f,0x006e6f69,0x00070006,0x0000001b,0x00000001,0x505f6c67,0x746e696f,
0x657a6953,0x00000000,0x00070006,0x0000001b,0x00000002,0x435f6c67,0x4470696c,0x61747369,
0x0065636e,0x00070006,0x0000001b,0x00000003,0x435f6c67,0x446c6c75,0x61747369,0x0065636e,
0x00030005,0x0000001d,0x00000000,0x00040047,0x0000000c,0x0000000b,0x0000002a,0x00030047,
0x0000001b,0x00000002,0x00050048,0x0000001b,0x00000000,0x0000000b,0x00000000,0x00050048,
0x0000001b,0x00000001,0x0000000b,0x00000001,0x00050048,0x0000001b,0x00000002,0x0000000b,
0x00000003,0x00050048,0x0000001b,0x00000003,0x0000000b,0x00000004,0x00020013,0x00000002,
0x00030021,0x00000003,0x00000002,0x00030016,0x00000006,0x00000020,0x00040017,0x00000007,
0x00000006,0x00000002,0x00040020,0x00000008,0x00000007,0x00000007,0x00040015,0x0000000a,
0x00000020,0x00000001,0x00040020,0x0000000b,0x00000001,0x0000000a,0x0004003b,0x0000000b,
0x0000000c,0x00000001,0x0004002b,0x0000000a,0x0000000e,0x00000001,0x0004002b,0x0000000a,
0x00000010,0x00000002,0x00040017,0x00000017,0x00000006,0x00000004,0x00040015,0x00000018,
0x00000020,0x00000000,0x0004002b,0x00000018,0x00000019,0x00000001,0x0004001c,0x0000001a,
0x00000006,0x00000019,0x0006001e,0x0000001b,0x00000017,0x00000006,0x0000001a,0x0000001a,
0x00040020,0x0000001c,0x00000003,0x0000001b,0x0004003b,0x0000001c,0x0000001d,0x00000003,
0x0004002b,0x0000000a,0x0000001e,0x00000000,0x0004002b,0x00000006,0x00000020,0x40000000,
0x0004002b,0x00000006,0x00000022,0x3f800000,0x0004002b,0x00000006,0x00000025,0x00000000,
0x00040020,0x00000029,0x00000003,0x00000017,0x00050036,0x00000002,0x00000004,0x00000000,
0x00000003,0x000200f8,0x00000005,0x0004003b,0x00000008,0x00000009,0x00000007,0x0004003d,
0x0000000a,0x0000000d,0x0000000c,0x000500c4,0x0000000a,0x0000000f,0x0000000d,0x0000000e,
0x000500c7,0x0000000a,0x00000011,0x0000000f,0x00000010,0x0004006f,0x00000006,0x00000012,
0x00000011,0x0004003d,0x0000000a,0x00000013,0x0000000c,0x000500c7,0x0000000a,0x00000014,
0x00000013,0x00000010,0x0004006f,0x00000006,0x00000015,0x00000014,0x00050050,0x00000007,
0x00000016,0x00000012,0x00000015,0x0003003e,0x00000009,0x00000016,0x0004003d,0x00000007,
0x0000001f,0x00000009,0x0005008e,0x00000007,0x00000021,0x0000001f,0x00000020,0x00050050,
0x00000007,0x00000023,0x00000022,0x00000022,0x00050083,0x00000007,0x00000024,0x00000021,
0x00000023,0x00050051,0x00000006,0x00000026,0x00000024,0x00000000,0x00050051,0x00000006,
0x00000027,0x00000024,0x00000001,0x00070050,0x00000017,0x00000028,0x00000026,0x00000027,
0x00000025,0x00000022,0x00050041,0x00000029,0x0000002a,0x0000001d,0x0000001e,0x0003003e,
0x0000002a,0x00000028,0x000100fd,0x00010038
};
// 1115.1.0
#pragma once
static const uint32_t spv_smoke_frag[] = {
0x07230203,0x00010000,0x0008000b,0x00000012,0x00000000,0x00020011,0x00000001,0x0006000b,
0x00000001,0x4c534c47,0x6474732e,0x3035342e,0x00000000,0x0003000e,0x00000000,0x00000001,
0x0006000f,0x00000004,0x00000004,0x6e69616d,0x00000000,0x00000009,0x00030010,0x00000004,
0x00000007,0x00030003,0x00000002,0x000001c2,0x00040005,0x00000004,0x6e69616d,0x00000000,
0x00030005,0x00000009,0x0000006f,0x00030005,0x0000000a,0x00004350,0x00050006,0x0000000a,
0x00000000,0x6f6c6f63,0x00000072,0x00030005,0x0000000c,0x00006370,0x00040047,0x00000009,
0x0000001e,0x00000000,0x00030047,0x0000000a,0x00000002,0x00050048,0x0000000a,0x00000000,
0x00000023,0x00000000,0x00020013,0x00000002,0x00030021,0x00000003,0x00000002,0x00030016,
0x00000006,0x00000020,0x00040017,0x00000007,0x00000006,0x00000004,0x00040020,0x00000008,
0x00000003,0x00000007,0x0004003b,0x00000008,0x00000009,0x00000003,0x0003001e,0x0000000a,
0x00000007,0x00040020,0x0000000b,0x00000009,0x0000000a,0x0004003b,0x0000000b,0x0000000c,
0x00000009,0x00040015,0x0000000d,0x00000020,0x00000001,0x0004002b,0x0000000d,0x0000000e,
0x00000000,0x00040020,0x0000000f,0x00000009,0x00000007,0x00050036,0x00000002,0x00000004,
0x00000000,0x00000003,0x000200f8,0x00000005,0x00050041,0x0000000f,0x00000010,0x0000000c,
0x0000000e,0x0004003d,0x00000007,0x00000011,0x00000010,0x0003003e,0x00000009,0x00000011,
0x000100fd,0x00010038
};