wine/vkd3d
0
0
Fork 0
mirror of https://gitlab.winehq.org/wine/vkd3d.git synced 2025-12-15 08:03:30 -08:00
Code Issues Packages Projects Releases Wiki Activity

tests/shader_runner: Introduce struct input_layout.

Browse Source
This commit is contained in:
Francisco Casas
2025-12-10 13:15:22 -03:00
committed by Henri Verbeet
parent 9fae991877
commit be3912f600
Notes: Henri Verbeet 2025-12-11 19:10:21 +01:00 
Approved-by: Giovanni Mascellani (@giomasce)
Approved-by: Henri Verbeet (@hverbeet)
Merge-Request: https://gitlab.winehq.org/wine/vkd3d/-/merge_requests/1229
8 changed files with 71 additions and 56 deletions
Download Patch File Download Diff File Expand all files Collapse all files

46
tests/shader_runner.c
View File

@@ -113,6 +113,23 @@ void fatal_error(const char *format, ...)
exit(1);
}
static void input_layout_clear(struct input_layout *l)
{
size_t i;
for (i = 0; i < l->element_count; ++i)
{
free(l->elements[i].name);
}
l->element_count = 0;
}
static void input_layout_cleanup(struct input_layout *l)
{
input_layout_clear(l);
free(l->elements);
}
enum parse_state
{
STATE_NONE,
@@ -818,9 +835,9 @@ static void parse_input_layout_directive(struct shader_runner *runner, const cha
struct input_element *element;
const char *rest;
vkd3d_array_reserve((void **)&runner->input_elements, &runner->input_element_capacity,
runner->input_element_count + 1, sizeof(*runner->input_elements));
element = &runner->input_elements[runner->input_element_count++];
vkd3d_array_reserve((void **)&runner->input.elements, &runner->input.element_capacity,
runner->input.element_count + 1, sizeof(*runner->input.elements));
element = &runner->input.elements[runner->input.element_count++];
element->slot = strtoul(line, (char **)&rest, 10);
if (rest == line)
@@ -1213,18 +1230,17 @@ static void parse_test_directive(struct shader_runner *runner, const char *line)
set_default_target(runner);
for (i = 0; i < runner->input_element_count; ++i)
free(runner->input_elements[i].name);
input_layout_clear(&runner->input);
vkd3d_array_reserve((void **)&runner->input_elements, &runner->input_element_capacity,
1, sizeof(*runner->input_elements));
element = &runner->input_elements[0];
vkd3d_array_reserve((void **)&runner->input.elements,
&runner->input.element_capacity, 1, sizeof(*runner->input.elements));
element = &runner->input.elements[0];
element->name = strdup("position");
element->slot = 0;
element->format = DXGI_FORMAT_R32G32_FLOAT;
element->texel_size = sizeof(*quad);
element->index = 0;
runner->input_element_count = 1;
runner->input.element_count = 1;
memset(&params, 0, sizeof(params));
params.desc.slot = 0;
@@ -1887,9 +1903,9 @@ unsigned int get_vb_stride(const struct shader_runner *runner, unsigned int slot
/* We currently don't deal with vertex formats less than 32 bits, so don't
* bother with alignment. */
for (i = 0; i < runner->input_element_count; ++i)
for (i = 0; i < runner->input.element_count; ++i)
{
const struct input_element *element = &runner->input_elements[i];
const struct input_element *element = &runner->input.elements[i];
if (element->slot == slot)
stride += element->texel_size;
@@ -2857,9 +2873,7 @@ void run_shader_tests(struct shader_runner *runner, const struct shader_runner_c
{
state = STATE_INPUT_LAYOUT;
for (i = 0; i < runner->input_element_count; ++i)
free(runner->input_elements[i].name);
runner->input_element_count = 0;
input_layout_clear(&runner->input);
}
else if (!strcmp(line, "[descriptors]\n"))
{
@@ -2931,9 +2945,7 @@ void run_shader_tests(struct shader_runner *runner, const struct shader_runner_c
/* Pop line_number context. */
vkd3d_test_pop_context();
for (i = 0; i < runner->input_element_count; ++i)
free(runner->input_elements[i].name);
free(runner->input_elements);
input_layout_cleanup(&runner->input);
for (i = 0; i < SHADER_TYPE_COUNT; ++i)
free(runner->shader_source[i]);
free(runner->uniforms);

7
tests/shader_runner.h
View File

@@ -282,8 +282,11 @@ struct shader_runner
struct sampler samplers[MAX_SAMPLERS];
size_t sampler_count;
struct input_element *input_elements;
size_t input_element_count, input_element_capacity;
struct input_layout
{
struct input_element *elements;
size_t element_count, element_capacity;
} input;
IDxcCompiler3 *dxc_compiler;

10
tests/shader_runner_d3d11.c
View File

@@ -972,15 +972,15 @@ static bool d3d11_runner_draw(struct shader_runner *r,
ID3D11SamplerState_Release(d3d11_sampler);
}
if (runner->r.input_element_count)
if (runner->r.input.element_count)
{
D3D11_INPUT_ELEMENT_DESC *descs;
ID3D11InputLayout *input_layout;
descs = calloc(runner->r.input_element_count, sizeof(*descs));
for (i = 0; i < runner->r.input_element_count; ++i)
descs = calloc(runner->r.input.element_count, sizeof(*descs));
for (i = 0; i < runner->r.input.element_count; ++i)
{
const struct input_element *element = &runner->r.input_elements[i];
const struct input_element *element = &runner->r.input.elements[i];
D3D11_INPUT_ELEMENT_DESC *desc = &descs[i];
desc->SemanticName = element->name;
@@ -991,7 +991,7 @@ static bool d3d11_runner_draw(struct shader_runner *r,
desc->InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
}
hr = ID3D11Device_CreateInputLayout(device, descs, runner->r.input_element_count,
hr = ID3D11Device_CreateInputLayout(device, descs, runner->r.input.element_count,
ID3D10Blob_GetBufferPointer(vs_code), ID3D10Blob_GetBufferSize(vs_code), &input_layout);
ok(hr == S_OK, "Failed to create input layout, hr %#lx.\n", hr);
ID3D11DeviceContext_IASetInputLayout(context, input_layout);

10
tests/shader_runner_d3d12.c
View File

@@ -571,10 +571,10 @@ static D3D12_PRIMITIVE_TOPOLOGY_TYPE d3d12_primitive_topology_type_from_primitiv
static D3D12_INPUT_ELEMENT_DESC *create_element_descs(const struct d3d12_shader_runner *runner)
{
D3D12_INPUT_ELEMENT_DESC *input_element_descs = calloc(runner->r.input_element_count, sizeof(*input_element_descs));
for (size_t i = 0; i < runner->r.input_element_count; ++i)
D3D12_INPUT_ELEMENT_DESC *input_element_descs = calloc(runner->r.input.element_count, sizeof(*input_element_descs));
for (size_t i = 0; i < runner->r.input.element_count; ++i)
{
const struct input_element *element = &runner->r.input_elements[i];
const struct input_element *element = &runner->r.input.elements[i];
D3D12_INPUT_ELEMENT_DESC *desc = &input_element_descs[i];
desc->SemanticName = element->name;
@@ -650,7 +650,7 @@ static ID3D12PipelineState *create_pipeline(struct d3d12_shader_runner *runner,
input_element_descs = create_element_descs(runner);
pso_desc.InputLayout.pInputElementDescs = input_element_descs;
pso_desc.InputLayout.NumElements = runner->r.input_element_count;
pso_desc.InputLayout.NumElements = runner->r.input.element_count;
hr = ID3D12Device_CreateGraphicsPipelineState(device, &pso_desc,
&IID_ID3D12PipelineState, (void **)&pso);
@@ -776,7 +776,7 @@ static ID3D12PipelineState *create_pipeline_device2(struct d3d12_shader_runner *
return NULL;
input_element_descs = create_element_descs(runner);
pipeline.input_layout.input_layout.NumElements = runner->r.input_element_count;
pipeline.input_layout.input_layout.NumElements = runner->r.input.element_count;
pipeline.input_layout.input_layout.pInputElementDescs = input_element_descs;
for (size_t i = 0; i < runner->r.resource_count; ++i)

14
tests/shader_runner_d3d9.c
View File

@@ -478,10 +478,10 @@ static bool d3d9_runner_draw(struct shader_runner *r,
ok(hr == D3D_OK, "Failed to set uniforms, hr %#lx.\n", hr);
}
decl_elements = calloc(runner->r.input_element_count + 1, sizeof(*decl_elements));
for (i = 0; i < runner->r.input_element_count; ++i)
decl_elements = calloc(runner->r.input.element_count + 1, sizeof(*decl_elements));
for (i = 0; i < runner->r.input.element_count; ++i)
{
const struct input_element *src_element = &runner->r.input_elements[i];
const struct input_element *src_element = &runner->r.input.elements[i];
D3DVERTEXELEMENT9 *dst_element = &decl_elements[i];
dst_element->Stream = src_element->slot;
@@ -492,7 +492,7 @@ static bool d3d9_runner_draw(struct shader_runner *r,
/* The offset will be filled below. */
}
decl_elements[runner->r.input_element_count] = decl_element_end;
decl_elements[runner->r.input.element_count] = decl_element_end;
fb_width = ~0u;
fb_height = ~0u;
@@ -534,12 +534,12 @@ static bool d3d9_runner_draw(struct shader_runner *r,
vkd3d_unreachable();
case RESOURCE_TYPE_VERTEX_BUFFER:
for (j = 0; j < runner->r.input_element_count; ++j)
for (j = 0; j < runner->r.input.element_count; ++j)
{
if (runner->r.input_elements[j].slot == resource->r.desc.slot)
if (runner->r.input.elements[j].slot == resource->r.desc.slot)
{
decl_elements[j].Offset = stride;
stride += runner->r.input_elements[j].texel_size;
stride += runner->r.input.elements[j].texel_size;
}
}

10
tests/shader_runner_gl.c
View File

@@ -1415,13 +1415,13 @@ static bool gl_runner_draw(struct shader_runner *r,
case RESOURCE_TYPE_VERTEX_BUFFER:
assert(resource->r.desc.slot < ARRAY_SIZE(vbo_info));
vbo_info[resource->r.desc.slot].id = resource->id;
for (j = 0; j < runner->r.input_element_count; ++j)
for (j = 0; j < runner->r.input.element_count; ++j)
{
if (runner->r.input_elements[j].slot != resource->r.desc.slot)
if (runner->r.input.elements[j].slot != resource->r.desc.slot)
continue;
assert(j < ARRAY_SIZE(attribute_offsets));
attribute_offsets[j] = (uint8_t *)(uintptr_t)vbo_info[resource->r.desc.slot].stride;
vbo_info[resource->r.desc.slot].stride += runner->r.input_elements[j].texel_size;
vbo_info[resource->r.desc.slot].stride += runner->r.input.elements[j].texel_size;
}
break;
}
@@ -1450,9 +1450,9 @@ static bool gl_runner_draw(struct shader_runner *r,
ok(!ret, "Failed to parse input signature, error %d.\n", ret);
map = runner->attribute_map;
for (i = 0, runner->attribute_map = 0; i < runner->r.input_element_count; ++i)
for (i = 0, runner->attribute_map = 0; i < runner->r.input.element_count; ++i)
{
const struct input_element *element = &runner->r.input_elements[i];
const struct input_element *element = &runner->r.input.elements[i];
const struct vkd3d_shader_signature_element *signature_element;
const struct format_info *format;

14
tests/shader_runner_metal.m
View File

@@ -858,13 +858,13 @@ static bool metal_runner_draw(struct shader_runner *r, D3D_PRIMITIVE_TOPOLOGY to
case RESOURCE_TYPE_VERTEX_BUFFER:
assert(resource->r.desc.slot < ARRAY_SIZE(vb_info));
for (j = 0, stride = 0; j < runner->r.input_element_count; ++j)
for (j = 0, stride = 0; j < runner->r.input.element_count; ++j)
{
if (runner->r.input_elements[j].slot != resource->r.desc.slot)
if (runner->r.input.elements[j].slot != resource->r.desc.slot)
continue;
assert(j < ARRAY_SIZE(attribute_offsets));
attribute_offsets[j] = stride;
stride += runner->r.input_elements[j].texel_size;
stride += runner->r.input.elements[j].texel_size;
}
if (!stride)
break;
@@ -898,12 +898,12 @@ static bool metal_runner_draw(struct shader_runner *r, D3D_PRIMITIVE_TOPOLOGY to
[encoder setFragmentBuffer:argument_buffer offset:0 atIndex:0];
[argument_buffer autorelease];
if (runner->r.input_element_count > 32)
fatal_error("Unsupported input element count %zu.\n", runner->r.input_element_count);
if (runner->r.input.element_count > 32)
fatal_error("Unsupported input element count %zu.\n", runner->r.input.element_count);
for (i = 0; i < runner->r.input_element_count; ++i)
for (i = 0; i < runner->r.input.element_count; ++i)
{
const struct input_element *element = &runner->r.input_elements[i];
const struct input_element *element = &runner->r.input.elements[i];
const struct vkd3d_shader_signature_element *signature_element;
MTLVertexAttributeDescriptor *attribute;

16
tests/shader_runner_vulkan.c
View File

@@ -823,13 +823,13 @@ static VkPipeline create_graphics_pipeline(struct vulkan_shader_runner *runner,
return VK_NULL_HANDLE;
}
if (runner->r.input_element_count > ARRAY_SIZE(input_attributes))
fatal_error("Input element count %zu is too high.\n", runner->r.input_element_count);
if (runner->r.input.element_count > ARRAY_SIZE(input_attributes))
fatal_error("Input element count %zu is too high.\n", runner->r.input.element_count);
for (i = 0; i < runner->r.input_element_count; ++i)
for (i = 0; i < runner->r.input.element_count; ++i)
{
VkVertexInputAttributeDescription *attribute = &input_attributes[i];
const struct input_element *element = &runner->r.input_elements[i];
const struct input_element *element = &runner->r.input.elements[i];
const struct vkd3d_shader_signature_element *signature_element;
signature_element = vkd3d_shader_find_signature_element(
@@ -842,7 +842,7 @@ static VkPipeline create_graphics_pipeline(struct vulkan_shader_runner *runner,
/* The offset will be filled below. */
}
input_desc.vertexAttributeDescriptionCount = runner->r.input_element_count;
input_desc.vertexAttributeDescriptionCount = runner->r.input.element_count;
input_desc.pVertexAttributeDescriptions = input_attributes;
input_desc.pVertexBindingDescriptions = input_bindings;
@@ -887,12 +887,12 @@ static VkPipeline create_graphics_pipeline(struct vulkan_shader_runner *runner,
binding->stride = 0;
binding->inputRate = VK_VERTEX_INPUT_RATE_VERTEX;
for (j = 0; j < runner->r.input_element_count; ++j)
for (j = 0; j < runner->r.input.element_count; ++j)
{
if (runner->r.input_elements[j].slot == resource->r.desc.slot)
if (runner->r.input.elements[j].slot == resource->r.desc.slot)
{
input_attributes[j].offset = binding->stride;
binding->stride += runner->r.input_elements[j].texel_size;
binding->stride += runner->r.input.elements[j].texel_size;
}
}
break;