The open source OpenXR runtime
c/render: Use new Vulkan helpers
+49
-408
+5
-118
src/xrt/compositor/render/comp_compute.c
+5
-118
src/xrt/compositor/render/comp_compute.c
···
85
85
*
86
86
*/
87
87
88
-
static VkResult
89
-
create_command_buffer(struct vk_bundle *vk, VkCommandBuffer *out_cmd)
90
-
{
91
-
VkResult ret;
92
-
93
-
VkCommandBufferAllocateInfo cmd_buffer_info = {
94
-
.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,
95
-
.commandPool = vk->cmd_pool,
96
-
.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY,
97
-
.commandBufferCount = 1,
98
-
};
99
-
100
-
VkCommandBuffer cmd = VK_NULL_HANDLE;
101
-
102
-
os_mutex_lock(&vk->cmd_pool_mutex);
103
-
104
-
ret = vk->vkAllocateCommandBuffers( //
105
-
vk->device, //
106
-
&cmd_buffer_info, //
107
-
&cmd); //
108
-
109
-
os_mutex_unlock(&vk->cmd_pool_mutex);
110
-
111
-
if (ret != VK_SUCCESS) {
112
-
VK_ERROR(vk, "vkCreateFramebuffer failed: %s", vk_result_string(ret));
113
-
return ret;
114
-
}
115
-
116
-
*out_cmd = cmd;
117
-
118
-
return VK_SUCCESS;
119
-
}
120
-
121
-
static void
122
-
destroy_command_buffer(struct vk_bundle *vk, VkCommandBuffer command_buffer)
123
-
{
124
-
os_mutex_lock(&vk->cmd_pool_mutex);
125
-
126
-
vk->vkFreeCommandBuffers( //
127
-
vk->device, // device
128
-
vk->cmd_pool, // commandPool
129
-
1, // commandBufferCount
130
-
&command_buffer); // pCommandBuffers
131
-
132
-
os_mutex_unlock(&vk->cmd_pool_mutex);
133
-
}
134
-
135
-
static VkResult
136
-
begin_command_buffer(struct vk_bundle *vk, VkCommandBuffer command_buffer)
137
-
{
138
-
VkResult ret;
139
-
140
-
VkCommandBufferBeginInfo command_buffer_info = {
141
-
.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
142
-
};
143
-
144
-
ret = vk->vkBeginCommandBuffer( //
145
-
command_buffer, //
146
-
&command_buffer_info); //
147
-
if (ret != VK_SUCCESS) {
148
-
VK_ERROR(vk, "vkBeginCommandBuffer failed: %s", vk_result_string(ret));
149
-
return ret;
150
-
}
151
-
152
-
return VK_SUCCESS;
153
-
}
154
-
155
-
static VkResult
156
-
end_command_buffer(struct vk_bundle *vk, VkCommandBuffer command_buffer)
157
-
{
158
-
VkResult ret;
159
-
160
-
// End the command buffer.
161
-
ret = vk->vkEndCommandBuffer( //
162
-
command_buffer); //
163
-
if (ret != VK_SUCCESS) {
164
-
VK_ERROR(vk, "vkEndCommandBuffer failed: %s", vk_result_string(ret));
165
-
return ret;
166
-
}
167
-
168
-
return VK_SUCCESS;
169
-
}
170
-
171
-
static VkResult
172
-
create_descriptor_set(struct vk_bundle *vk,
173
-
VkDescriptorPool descriptor_pool,
174
-
VkDescriptorSetLayout descriptor_layout,
175
-
VkDescriptorSet *out_descriptor_set)
176
-
{
177
-
VkResult ret;
178
-
179
-
VkDescriptorSetAllocateInfo alloc_info = {
180
-
.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO,
181
-
.descriptorPool = descriptor_pool,
182
-
.descriptorSetCount = 1,
183
-
.pSetLayouts = &descriptor_layout,
184
-
};
185
-
186
-
VkDescriptorSet descriptor_set = VK_NULL_HANDLE;
187
-
ret = vk->vkAllocateDescriptorSets( //
188
-
vk->device, //
189
-
&alloc_info, //
190
-
&descriptor_set); //
191
-
if (ret != VK_SUCCESS) {
192
-
VK_DEBUG(vk, "vkAllocateDescriptorSets failed: %s", vk_result_string(ret));
193
-
return ret;
194
-
}
195
-
196
-
*out_descriptor_set = descriptor_set;
197
-
198
-
return VK_SUCCESS;
199
-
}
200
-
201
88
XRT_MAYBE_UNUSED static void
202
89
update_compute_discriptor_set(struct vk_bundle *vk,
203
90
uint32_t src_binding,
···
375
262
struct vk_bundle *vk = r->vk;
376
263
crc->r = r;
377
264
378
-
C(create_command_buffer(vk, &crc->cmd));
265
+
C(vk_create_command_buffer(vk, &crc->cmd));
379
266
380
-
C(create_descriptor_set( //
267
+
C(vk_create_descriptor_set( //
381
268
vk, //
382
269
r->compute.descriptor_pool, // descriptor_pool
383
270
r->compute.descriptor_set_layout, // descriptor_set_layout
···
391
278
{
392
279
struct vk_bundle *vk = vk_from_crc(crc);
393
280
394
-
C(begin_command_buffer(vk, crc->cmd));
281
+
C(vk_begin_command_buffer(vk, crc->cmd));
395
282
396
283
return true;
397
284
}
···
401
288
{
402
289
struct vk_bundle *vk = vk_from_crc(crc);
403
290
404
-
C(end_command_buffer(vk, crc->cmd));
291
+
C(vk_end_command_buffer(vk, crc->cmd));
405
292
406
293
return true;
407
294
}
···
413
300
414
301
struct vk_bundle *vk = vk_from_crc(crc);
415
302
416
-
destroy_command_buffer(vk, crc->cmd);
303
+
vk_destroy_command_buffer(vk, crc->cmd);
417
304
418
305
// Reclaimed by vkResetDescriptorPool.
419
306
crc->descriptor_set = VK_NULL_HANDLE;
+6
-105
src/xrt/compositor/render/comp_rendering.c
+6
-105
src/xrt/compositor/render/comp_rendering.c
···
131
131
}
132
132
133
133
static VkResult
134
-
create_descriptor_set(struct vk_bundle *vk,
135
-
VkDescriptorPool descriptor_pool,
136
-
VkDescriptorSetLayout descriptor_layout,
137
-
VkDescriptorSet *out_descriptor_set)
138
-
{
139
-
VkResult ret;
140
-
141
-
VkDescriptorSetAllocateInfo alloc_info = {
142
-
.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO,
143
-
.descriptorPool = descriptor_pool,
144
-
.descriptorSetCount = 1,
145
-
.pSetLayouts = &descriptor_layout,
146
-
};
147
-
148
-
VkDescriptorSet descriptor_set = VK_NULL_HANDLE;
149
-
ret = vk->vkAllocateDescriptorSets(vk->device, //
150
-
&alloc_info, //
151
-
&descriptor_set); //
152
-
if (ret != VK_SUCCESS) {
153
-
VK_DEBUG(vk, "vkAllocateDescriptorSets failed: %s", vk_result_string(ret));
154
-
return ret;
155
-
}
156
-
157
-
*out_descriptor_set = descriptor_set;
158
-
159
-
return VK_SUCCESS;
160
-
}
161
-
162
-
static VkResult
163
134
create_framebuffer(struct vk_bundle *vk,
164
135
VkImageView image_view,
165
136
VkRenderPass render_pass,
···
192
163
}
193
164
194
165
*out_external_framebuffer = framebuffer;
195
-
196
-
return VK_SUCCESS;
197
-
}
198
-
199
-
static VkResult
200
-
create_command_buffer(struct vk_bundle *vk, VkCommandBuffer *out_cmd)
201
-
{
202
-
VkResult ret;
203
-
204
-
VkCommandBufferAllocateInfo cmd_buffer_info = {
205
-
.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,
206
-
.commandPool = vk->cmd_pool,
207
-
.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY,
208
-
.commandBufferCount = 1,
209
-
};
210
-
211
-
VkCommandBuffer cmd = VK_NULL_HANDLE;
212
-
213
-
os_mutex_lock(&vk->cmd_pool_mutex);
214
-
215
-
ret = vk->vkAllocateCommandBuffers(vk->device, //
216
-
&cmd_buffer_info, //
217
-
&cmd); //
218
-
219
-
os_mutex_unlock(&vk->cmd_pool_mutex);
220
-
221
-
if (ret != VK_SUCCESS) {
222
-
VK_ERROR(vk, "vkCreateFramebuffer failed: %s", vk_result_string(ret));
223
-
return ret;
224
-
}
225
-
226
-
*out_cmd = cmd;
227
-
228
-
return VK_SUCCESS;
229
-
}
230
-
231
-
static VkResult
232
-
begin_command_buffer(struct vk_bundle *vk, VkCommandBuffer command_buffer)
233
-
{
234
-
VkResult ret;
235
-
236
-
VkCommandBufferBeginInfo command_buffer_info = {
237
-
.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
238
-
};
239
-
240
-
ret = vk->vkBeginCommandBuffer(command_buffer, &command_buffer_info);
241
-
if (ret != VK_SUCCESS) {
242
-
VK_ERROR(vk, "vkBeginCommandBuffer failed: %s", vk_result_string(ret));
243
-
return ret;
244
-
}
245
166
246
167
return VK_SUCCESS;
247
168
}
···
507
428
NULL); // pDescriptorCopies
508
429
}
509
430
510
-
static void
511
-
destroy_command_buffer(struct vk_bundle *vk, VkCommandBuffer command_buffer)
512
-
{
513
-
os_mutex_lock(&vk->cmd_pool_mutex);
514
-
515
-
vk->vkFreeCommandBuffers( //
516
-
vk->device, // device
517
-
vk->cmd_pool, // commandPool
518
-
1, // commandBufferCount
519
-
&command_buffer); // pCommandBuffers
520
-
521
-
os_mutex_unlock(&vk->cmd_pool_mutex);
522
-
}
523
-
524
431
525
432
/*
526
433
*
···
595
502
* Per rendering.
596
503
*/
597
504
598
-
C(create_command_buffer(vk, &rr->cmd));
505
+
C(vk_create_command_buffer(vk, &rr->cmd));
599
506
600
-
C(begin_command_buffer(vk, rr->cmd));
507
+
C(vk_begin_command_buffer(vk, rr->cmd));
601
508
602
509
603
510
/*
604
511
* Mesh per view
605
512
*/
606
513
607
-
C(create_descriptor_set( //
514
+
C(vk_create_descriptor_set( //
608
515
vk, // vk_bundle
609
516
r->mesh.descriptor_pool, // descriptor_pool
610
517
r->mesh.descriptor_set_layout, // descriptor_set_layout
611
518
&rr->views[0].mesh.descriptor_set)); // descriptor_set
612
519
613
-
C(create_descriptor_set( //
520
+
C(vk_create_descriptor_set( //
614
521
vk, // vk_bundle
615
522
r->mesh.descriptor_pool, // descriptor_pool
616
523
r->mesh.descriptor_set_layout, // descriptor_set_layout
···
623
530
comp_rendering_finalize(struct comp_rendering *rr)
624
531
{
625
532
struct vk_bundle *vk = vk_from_rr(rr);
626
-
VkResult ret;
627
533
628
-
// End the command buffer.
629
-
ret = vk->vkEndCommandBuffer(rr->cmd);
630
-
if (ret != VK_SUCCESS) {
631
-
VK_ERROR(vk, "vkEndCommandBuffer failed: %s", vk_result_string(ret));
632
-
return;
633
-
}
534
+
vk_end_command_buffer(vk, rr->cmd);
634
535
}
635
536
636
537
void
···
639
540
struct vk_bundle *vk = vk_from_rr(rr);
640
541
struct comp_resources *r = rr->r;
641
542
642
-
destroy_command_buffer(vk, rr->cmd);
543
+
vk_destroy_command_buffer(vk, rr->cmd);
643
544
rr->cmd = VK_NULL_HANDLE;
644
545
645
546
// Reclaimed by vkResetDescriptorPool.
+38
-185
src/xrt/compositor/render/comp_resources.c
+38
-185
src/xrt/compositor/render/comp_resources.c
···
36
36
}
37
37
38
38
39
-
static VkResult
40
-
create_pipeline_cache(struct vk_bundle *vk, VkPipelineCache *out_pipeline_cache)
41
-
{
42
-
VkResult ret;
43
-
44
-
VkPipelineCacheCreateInfo pipeline_cache_info = {
45
-
.sType = VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO,
46
-
};
47
-
48
-
VkPipelineCache pipeline_cache;
49
-
ret = vk->vkCreatePipelineCache(vk->device, //
50
-
&pipeline_cache_info, //
51
-
NULL, //
52
-
&pipeline_cache); //
53
-
if (ret != VK_SUCCESS) {
54
-
VK_ERROR(vk, "vkCreatePipelineCache failed: %s", vk_result_string(ret));
55
-
return ret;
56
-
}
57
-
58
-
*out_pipeline_cache = pipeline_cache;
59
-
60
-
return VK_SUCCESS;
61
-
}
62
-
63
-
static VkResult
64
-
create_pipeline_layout(struct vk_bundle *vk,
65
-
VkDescriptorSetLayout descriptor_set_layout,
66
-
VkPipelineLayout *out_pipeline_layout)
67
-
{
68
-
VkResult ret;
69
-
70
-
VkPipelineLayoutCreateInfo pipeline_layout_info = {
71
-
.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,
72
-
.setLayoutCount = 1,
73
-
.pSetLayouts = &descriptor_set_layout,
74
-
};
75
-
76
-
VkPipelineLayout pipeline_layout = VK_NULL_HANDLE;
77
-
ret = vk->vkCreatePipelineLayout(vk->device, //
78
-
&pipeline_layout_info, //
79
-
NULL, //
80
-
&pipeline_layout); //
81
-
if (ret != VK_SUCCESS) {
82
-
VK_ERROR(vk, "vkCreatePipelineLayout failed: %s", vk_result_string(ret));
83
-
return ret;
84
-
}
85
-
86
-
*out_pipeline_layout = pipeline_layout;
87
-
88
-
return VK_SUCCESS;
89
-
}
90
-
91
-
static VkResult
92
-
create_descriptor_pool(struct vk_bundle *vk,
93
-
uint32_t num_uniform_per_desc,
94
-
uint32_t num_sampler_per_desc,
95
-
uint32_t num_storage_per_desc,
96
-
uint32_t num_descs,
97
-
bool freeable,
98
-
VkDescriptorPool *out_descriptor_pool)
99
-
{
100
-
VkResult ret;
101
-
102
-
103
-
uint32_t count = 0;
104
-
VkDescriptorPoolSize pool_sizes[3] = {0};
105
-
106
-
if (num_uniform_per_desc > 0) {
107
-
pool_sizes[count].type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
108
-
pool_sizes[count].descriptorCount = num_uniform_per_desc * num_descs;
109
-
count++;
110
-
}
111
-
112
-
if (num_sampler_per_desc > 0) {
113
-
pool_sizes[count].type = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
114
-
pool_sizes[count].descriptorCount = num_sampler_per_desc * num_descs;
115
-
count++;
116
-
}
117
-
118
-
if (num_storage_per_desc > 0) {
119
-
pool_sizes[count].type = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE;
120
-
pool_sizes[count].descriptorCount = num_storage_per_desc * num_descs;
121
-
count++;
122
-
}
123
-
124
-
assert(count > 0 && count <= ARRAY_SIZE(pool_sizes));
125
-
126
-
VkDescriptorPoolCreateFlags flags = 0;
127
-
128
-
if (freeable) {
129
-
flags |= VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT;
130
-
}
131
-
132
-
VkDescriptorPoolCreateInfo descriptor_pool_info = {
133
-
.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO,
134
-
.flags = flags,
135
-
.maxSets = num_descs,
136
-
.poolSizeCount = count,
137
-
.pPoolSizes = pool_sizes,
138
-
};
139
-
140
-
VkDescriptorPool descriptor_pool = VK_NULL_HANDLE;
141
-
ret = vk->vkCreateDescriptorPool(vk->device, //
142
-
&descriptor_pool_info, //
143
-
NULL, //
144
-
&descriptor_pool); //
145
-
if (ret != VK_SUCCESS) {
146
-
VK_ERROR(vk, "vkCreateRenderPass failed: %s", vk_result_string(ret));
147
-
return ret;
148
-
}
149
-
150
-
*out_descriptor_pool = descriptor_pool;
151
-
152
-
return VK_SUCCESS;
153
-
}
154
-
155
-
156
39
/*
157
40
*
158
41
* Mesh
···
352
235
}
353
236
354
237
*out_descriptor_set_layout = descriptor_set_layout;
355
-
356
-
return VK_SUCCESS;
357
-
}
358
-
359
-
static VkResult
360
-
create_compute_pipeline(struct vk_bundle *vk,
361
-
VkPipelineCache pipeline_cache,
362
-
VkShaderModule shader,
363
-
VkPipelineLayout pipeline_layout,
364
-
VkPipeline *out_compute_pipeline)
365
-
{
366
-
VkResult ret;
367
-
368
-
VkPipelineShaderStageCreateInfo shader_stage_info = {
369
-
.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
370
-
.pNext = NULL,
371
-
.stage = VK_SHADER_STAGE_COMPUTE_BIT,
372
-
.module = shader,
373
-
.pName = "main",
374
-
};
375
-
376
-
VkComputePipelineCreateInfo pipeline_info = {
377
-
.sType = VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO,
378
-
.pNext = NULL,
379
-
.flags = 0,
380
-
.stage = shader_stage_info,
381
-
.layout = pipeline_layout,
382
-
};
383
-
384
-
VkPipeline pipeline = VK_NULL_HANDLE;
385
-
ret = vk->vkCreateComputePipelines( //
386
-
vk->device, //
387
-
pipeline_cache, //
388
-
1, //
389
-
&pipeline_info, //
390
-
NULL, //
391
-
&pipeline); //
392
-
if (ret != VK_SUCCESS) {
393
-
VK_DEBUG(vk, "vkCreateComputePipelines failed: %s", vk_result_string(ret));
394
-
return ret;
395
-
}
396
-
397
-
*out_compute_pipeline = pipeline;
398
238
399
239
return VK_SUCCESS;
400
240
}
···
671
511
* Shared
672
512
*/
673
513
674
-
C(create_pipeline_cache(vk, &r->pipeline_cache));
514
+
C(vk_create_pipeline_cache(vk, &r->pipeline_cache));
675
515
676
516
677
517
/*
678
518
* Mesh static.
679
519
*/
680
520
681
-
C(create_descriptor_pool(vk, // vk_bundle
682
-
1, // num_uniform_per_desc
683
-
1, // num_sampler_per_desc
684
-
0, // num_storage_per_desc
685
-
16 * 2, // num_descs
686
-
false, // freeable
687
-
&r->mesh.descriptor_pool)); // out_descriptor_pool
521
+
struct vk_descriptor_pool_info mesh_pool_info = {
522
+
.uniform_per_descriptor_count = 1,
523
+
.sampler_per_descriptor_count = 1,
524
+
.storage_image_per_descriptor_count = 0,
525
+
.storage_buffer_per_descriptor_count = 0,
526
+
.descriptor_count = 16 * 2,
527
+
.freeable = false,
528
+
};
688
529
689
-
C(create_mesh_descriptor_set_layout(vk, // vk_bundle
690
-
r->mesh.src_binding, // src_binding
691
-
r->mesh.ubo_binding, // ubo_binding
692
-
&r->mesh.descriptor_set_layout)); // out_mesh_descriptor_set_layout
530
+
C(vk_create_descriptor_pool( //
531
+
vk, // vk_bundle
532
+
&mesh_pool_info, // info
533
+
&r->mesh.descriptor_pool)); // out_descriptor_pool
693
534
694
-
C(create_pipeline_layout(vk, // vk_bundle
695
-
r->mesh.descriptor_set_layout, // descriptor_set_layout
696
-
&r->mesh.pipeline_layout)); // out_pipeline_layout
535
+
C(create_mesh_descriptor_set_layout( //
536
+
vk, // vk_bundle
537
+
r->mesh.src_binding, // src_binding
538
+
r->mesh.ubo_binding, // ubo_binding
539
+
&r->mesh.descriptor_set_layout)); // out_mesh_descriptor_set_layout
540
+
541
+
C(vk_create_pipeline_layout( //
542
+
vk, // vk_bundle
543
+
r->mesh.descriptor_set_layout, // descriptor_set_layout
544
+
&r->mesh.pipeline_layout)); // out_pipeline_layout
697
545
698
546
if (!init_mesh_vertex_buffers(vk, //
699
547
&r->mesh.vbo, //
···
722
570
VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, // clamp_mode
723
571
&r->compute.default_sampler)); // out_sampler
724
572
725
-
C(create_descriptor_pool( //
573
+
struct vk_descriptor_pool_info compute_pool_info = {
574
+
.uniform_per_descriptor_count = 1,
575
+
.sampler_per_descriptor_count = 8,
576
+
.storage_image_per_descriptor_count = 1,
577
+
.storage_buffer_per_descriptor_count = 0,
578
+
.descriptor_count = 1,
579
+
.freeable = false,
580
+
};
581
+
582
+
C(vk_create_descriptor_pool( //
726
583
vk, // vk_bundle
727
-
1, // num_uniform_per_desc
728
-
8, // num_sampler_per_desc
729
-
1, // num_storage_per_desc
730
-
1, // num_descs
731
-
false, // freeable
584
+
&compute_pool_info, // info
732
585
&r->compute.descriptor_pool)); // out_descriptor_pool
733
586
734
587
C(create_compute_descriptor_set_layout( //
···
739
592
r->compute.ubo_binding, // ubo_binding,
740
593
&r->compute.descriptor_set_layout)); // out_descriptor_set_layout
741
594
742
-
C(create_pipeline_layout( //
595
+
C(vk_create_pipeline_layout( //
743
596
vk, // vk_bundle
744
597
r->compute.descriptor_set_layout, // descriptor_set_layout
745
598
&r->compute.pipeline_layout)); // out_pipeline_layout
746
599
747
-
C(create_compute_pipeline( //
600
+
C(vk_create_compute_pipeline( //
748
601
vk, // vk_bundle
749
602
r->pipeline_cache, // pipeline_cache
750
603
r->shaders->clear_comp, // shader
751
604
r->compute.pipeline_layout, // pipeline_layout
752
605
&r->compute.clear_pipeline)); // out_compute_pipeline
753
606
754
-
C(create_compute_pipeline( //
607
+
C(vk_create_compute_pipeline( //
755
608
vk, // vk_bundle
756
609
r->pipeline_cache, // pipeline_cache
757
610
r->shaders->distortion_comp, // shader
758
611
r->compute.pipeline_layout, // pipeline_layout
759
612
&r->compute.distortion_pipeline)); // out_compute_pipeline
760
613
761
-
C(create_compute_pipeline( //
614
+
C(vk_create_compute_pipeline( //
762
615
vk, // vk_bundle
763
616
r->pipeline_cache, // pipeline_cache
764
617
r->shaders->distortion_timewarp_comp, // shader