The open source OpenXR runtime
c/render: Name Vulkan objects
authored by
Simon Zeni
and committed by
Jakob Bornecrantz
2a513c14
38be815f
+116
-2
+5
src/xrt/compositor/render/render_compute.c
+5
src/xrt/compositor/render/render_compute.c
···
327
327
r->compute.layer.descriptor_set_layout, // descriptor_set_layout
328
328
&crc->layer_descriptor_sets[i]); // descriptor_set
329
329
VK_CHK_WITH_RET(ret, "vk_create_descriptor_set", false);
330
+
331
+
VK_NAME_OBJECT(vk, DESCRIPTOR_SET, crc->layer_descriptor_sets[i],
332
+
"render_compute layer descriptor set");
330
333
}
331
334
332
335
ret = vk_create_descriptor_set( //
···
335
338
r->compute.distortion.descriptor_set_layout, // descriptor_set_layout
336
339
&crc->shared_descriptor_set); // descriptor_set
337
340
VK_CHK_WITH_RET(ret, "vk_create_descriptor_set", false);
341
+
342
+
VK_NAME_OBJECT(vk, DESCRIPTOR_SET, crc->shared_descriptor_set, "render_compute shared descriptor set");
338
343
339
344
return true;
340
345
}
+9
src/xrt/compositor/render/render_distortion.c
+9
src/xrt/compositor/render/render_distortion.c
···
47
47
&image); // out_image
48
48
VK_CHK_AND_RET(ret, "vk_create_image_simple");
49
49
50
+
VK_NAME_OBJECT(vk, DEVICE_MEMORY, image, "distortion device_memory");
51
+
VK_NAME_OBJECT(vk, IMAGE, image, "distortion image");
52
+
50
53
VkImageSubresourceRange subresource_range = {
51
54
.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
52
55
.baseMipLevel = 0,
···
63
66
subresource_range, // subresource_range
64
67
&image_view); // out_image_view
65
68
VK_CHK_WITH_GOTO(ret, "vk_create_view", err_free);
69
+
70
+
VK_NAME_OBJECT(vk, IMAGE_VIEW, image, "distortion image view");
66
71
67
72
*out_device_memory = device_memory;
68
73
*out_image = image;
···
216
221
217
222
ret = render_buffer_init(vk, r_buffer, usage_flags, properties, size);
218
223
VK_CHK_WITH_GOTO(ret, "render_buffer_init", err_buffers);
224
+
VK_NAME_OBJECT(vk, BUFFER, r_buffer->buffer, "distortion r_buffer");
219
225
ret = render_buffer_init(vk, g_buffer, usage_flags, properties, size);
220
226
VK_CHK_WITH_GOTO(ret, "render_buffer_init", err_buffers);
227
+
VK_NAME_OBJECT(vk, BUFFER, g_buffer->buffer, "distortion g_buffer");
221
228
ret = render_buffer_init(vk, b_buffer, usage_flags, properties, size);
222
229
VK_CHK_WITH_GOTO(ret, "render_buffer_init", err_buffers);
230
+
VK_NAME_OBJECT(vk, BUFFER, b_buffer->buffer, "distortion b_buffer");
223
231
224
232
ret = render_buffer_map(vk, r_buffer);
225
233
VK_CHK_WITH_GOTO(ret, "render_buffer_map", err_buffers);
···
316
324
317
325
ret = vk_cmd_pool_create_and_begin_cmd_buffer_locked(vk, pool, 0, &upload_buffer);
318
326
VK_CHK_WITH_GOTO(ret, "vk_cmd_pool_create_and_begin_cmd_buffer_locked", err_unlock);
327
+
VK_NAME_OBJECT(vk, COMMAND_BUFFER, upload_buffer, "render_resources distortion command buffer");
319
328
320
329
for (uint32_t i = 0; i < RENDER_DISTORTION_NUM_IMAGES; i++) {
321
330
ret = create_and_queue_upload_locked( //
+21
-2
src/xrt/compositor/render/render_gfx.c
+21
-2
src/xrt/compositor/render/render_gfx.c
···
30
30
return rtr->r->vk;
31
31
}
32
32
33
-
/*!
34
-
* Get the @ref vk_bundle from @ref render_gfx.
33
+
/*gfx_target_resources framebuffer@ref render_gfx.
35
34
*/
36
35
static inline struct vk_bundle *
37
36
vk_from_rr(struct render_gfx *rr)
···
715
714
final_layout, // final_layout
716
715
&rgrp->render_pass); // out_render_pass
717
716
VK_CHK_WITH_RET(ret, "create_implicit_render_pass", false);
717
+
VK_NAME_OBJECT(vk, RENDER_PASS, rgrp->render_pass, "render_gfx_render_pass render pass");
718
718
719
719
struct mesh_params simple_params = {
720
720
.do_timewarp = false,
···
733
733
r->shaders->mesh_frag, // mesh_frag
734
734
&rgrp->mesh.pipeline); // out_mesh_pipeline
735
735
VK_CHK_WITH_RET(ret, "create_mesh_pipeline", false);
736
+
VK_NAME_OBJECT(vk, PIPELINE, rgrp->mesh.pipeline, "render_gfx_render_pass mesh pipeline");
736
737
737
738
struct mesh_params timewarp_params = {
738
739
.do_timewarp = true,
···
751
752
r->shaders->mesh_frag, // mesh_frag
752
753
&rgrp->mesh.pipeline_timewarp); // out_mesh_pipeline
753
754
VK_CHK_WITH_RET(ret, "create_mesh_pipeline", false);
755
+
VK_NAME_OBJECT(vk, PIPELINE, rgrp->mesh.pipeline_timewarp, "render_gfx_render_pass mesh pipeline timewarp");
754
756
755
757
const VkBlendFactor blend_factor_premultiplied_alpha = VK_BLEND_FACTOR_ONE;
756
758
const VkBlendFactor blend_factor_unpremultiplied_alpha = VK_BLEND_FACTOR_SRC_ALPHA;
···
766
768
r->shaders->layer_cylinder_frag, // module_frag
767
769
&rgrp->layer.cylinder_premultiplied_alpha); // out_pipeline
768
770
VK_CHK_WITH_RET(ret, "create_layer_pipeline", false);
771
+
VK_NAME_OBJECT(vk, PIPELINE, rgrp->layer.cylinder_premultiplied_alpha,
772
+
"render_gfx_render_pass cylinder premultiplied alpha");
769
773
770
774
ret = create_layer_pipeline( //
771
775
vk, // vk
···
777
781
r->shaders->layer_cylinder_frag, // module_frag
778
782
&rgrp->layer.cylinder_unpremultiplied_alpha); // out_pipeline
779
783
VK_CHK_WITH_RET(ret, "create_layer_pipeline", false);
784
+
VK_NAME_OBJECT(vk, PIPELINE, rgrp->layer.cylinder_unpremultiplied_alpha,
785
+
"render_gfx_render_pass cylinder unpremultiplied alpha");
780
786
781
787
// Equirect2
782
788
ret = create_layer_pipeline( //
···
789
795
r->shaders->layer_equirect2_frag, // module_frag
790
796
&rgrp->layer.equirect2_premultiplied_alpha); // out_pipeline
791
797
VK_CHK_WITH_RET(ret, "create_layer_pipeline", false);
798
+
VK_NAME_OBJECT(vk, PIPELINE, rgrp->layer.equirect2_premultiplied_alpha,
799
+
"render_gfx_render_pass equirect2 premultiplied alpha");
792
800
793
801
ret = create_layer_pipeline( //
794
802
vk, // vk
···
800
808
r->shaders->layer_equirect2_frag, // module_frag
801
809
&rgrp->layer.equirect2_unpremultiplied_alpha); // out_pipeline
802
810
VK_CHK_WITH_RET(ret, "create_layer_pipeline", false);
811
+
VK_NAME_OBJECT(vk, PIPELINE, rgrp->layer.equirect2_unpremultiplied_alpha,
812
+
"render_gfx_render_pass equirect2 unpremultiplied alpha");
803
813
804
814
// Projection.
805
815
ret = create_layer_pipeline( //
···
812
822
r->shaders->layer_shared_frag, // module_frag
813
823
&rgrp->layer.proj_premultiplied_alpha); // out_pipeline
814
824
VK_CHK_WITH_RET(ret, "create_layer_pipeline", false);
825
+
VK_NAME_OBJECT(vk, PIPELINE, rgrp->layer.proj_premultiplied_alpha,
826
+
"render_gfx_render_pass projection premultiplied alpha");
815
827
816
828
ret = create_layer_pipeline( //
817
829
vk, // vk
···
823
835
r->shaders->layer_shared_frag, // module_frag
824
836
&rgrp->layer.proj_unpremultiplied_alpha); // out_pipeline
825
837
VK_CHK_WITH_RET(ret, "create_layer_pipeline", false);
838
+
VK_NAME_OBJECT(vk, PIPELINE, rgrp->layer.proj_unpremultiplied_alpha,
839
+
"render_gfx_render_pass projection unpremultiplied alpha");
826
840
827
841
// Quad
828
842
ret = create_layer_pipeline( //
···
835
849
r->shaders->layer_shared_frag, // module_frag
836
850
&rgrp->layer.quad_premultiplied_alpha); // out_pipeline
837
851
VK_CHK_WITH_RET(ret, "create_layer_pipeline", false);
852
+
VK_NAME_OBJECT(vk, PIPELINE, rgrp->layer.quad_premultiplied_alpha,
853
+
"render_gfx_render_pass quad premultiplied alpha");
838
854
839
855
ret = create_layer_pipeline( //
840
856
vk, // vk
···
846
862
r->shaders->layer_shared_frag, // module_frag
847
863
&rgrp->layer.quad_unpremultiplied_alpha); // out_pipeline
848
864
VK_CHK_WITH_RET(ret, "create_layer_pipeline", false);
865
+
VK_NAME_OBJECT(vk, PIPELINE, rgrp->layer.quad_unpremultiplied_alpha,
866
+
"render_gfx_render_pass quad unpremultiplied alpha");
849
867
850
868
// Set fields.
851
869
rgrp->r = r;
···
904
922
extent.height, // height,
905
923
&rtr->framebuffer); // out_external_framebuffer
906
924
VK_CHK_WITH_RET(ret, "create_framebuffer", false);
925
+
VK_NAME_OBJECT(vk, FRAMEBUFFER, rtr->framebuffer, "render_gfx_target_resources framebuffer");
907
926
908
927
// Set fields.
909
928
rtr->rgrp = rgrp;
+80
src/xrt/compositor/render/render_resources.c
+80
src/xrt/compositor/render/render_resources.c
···
108
108
memory_property_flags, // memory_property_flags
109
109
vbo_size); // size
110
110
VK_CHK_WITH_RET(ret, "render_buffer_init", false);
111
+
VK_NAME_OBJECT(vk, BUFFER, vbo->buffer, "mesh vbo");
111
112
112
113
ret = render_buffer_write( //
113
114
vk, // vk_bundle
···
129
130
memory_property_flags, // memory_property_flags
130
131
ibo_size); // size
131
132
VK_CHK_WITH_RET(ret, "render_buffer_init", false);
133
+
VK_NAME_OBJECT(vk, BUFFER, ibo->buffer, "mesh ibo");
132
134
133
135
ret = render_buffer_write( //
134
136
vk, // vk_bundle
···
159
161
memory_property_flags, //
160
162
ubo_size); // size
161
163
VK_CHK_WITH_RET(ret, "render_buffer_init", false);
164
+
VK_NAME_OBJECT(vk, BUFFER, l_ubo, "mesh l_ubo");
162
165
163
166
ret = render_buffer_map(vk, l_ubo);
164
167
VK_CHK_WITH_RET(ret, "render_buffer_map", false);
···
169
172
memory_property_flags, //
170
173
ubo_size); // size
171
174
VK_CHK_WITH_RET(ret, "render_buffer_init", false);
175
+
VK_NAME_OBJECT(vk, BUFFER, l_ubo, "mesh r_ubo");
172
176
173
177
ret = render_buffer_map(vk, r_ubo);
174
178
VK_CHK_WITH_RET(ret, "render_buffer_map", false);
···
448
452
&image); // out_image
449
453
VK_CHK_WITH_RET(ret, "vk_create_image_mutable_rgba", false);
450
454
455
+
VK_NAME_OBJECT(vk, DEVICE_MEMORY, device_memory, "render_scratch_color_image device_memory");
456
+
VK_NAME_OBJECT(vk, IMAGE, image, "render_scratch_color_image image");
457
+
451
458
VkImageSubresourceRange subresource_range = {
452
459
.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
453
460
.baseMipLevel = 0,
···
466
473
&srgb_view); // out_image_view
467
474
VK_CHK_WITH_RET(ret, "vk_create_view_usage", false);
468
475
476
+
VK_NAME_OBJECT(vk, IMAGE_VIEW, srgb_view, "render_scratch_color_image image view srgb");
477
+
469
478
ret = vk_create_view_usage( //
470
479
vk, // vk_bundle
471
480
image, // image
···
475
484
subresource_range, // subresource_range
476
485
&unorm_view); // out_image_view
477
486
VK_CHK_WITH_RET(ret, "vk_create_view_usage", false);
487
+
488
+
VK_NAME_OBJECT(vk, IMAGE_VIEW, unorm_view, "render_scratch_color_image image view unorm");
478
489
479
490
rsci->device_memory = device_memory;
480
491
rsci->image = image;
···
553
564
&r->samplers.mock); // out_sampler
554
565
VK_CHK_WITH_RET(ret, "vk_create_sampler", false);
555
566
567
+
VK_NAME_OBJECT(vk, SAMPLER, r->samplers.mock, "render_resources sampler mock");
568
+
556
569
ret = vk_create_sampler( //
557
570
vk, // vk_bundle
558
571
VK_SAMPLER_ADDRESS_MODE_REPEAT, // clamp_mode
559
572
&r->samplers.repeat); // out_sampler
560
573
VK_CHK_WITH_RET(ret, "vk_create_sampler", false);
561
574
575
+
VK_NAME_OBJECT(vk, SAMPLER, r->samplers.repeat, "render_resources sampler repeat");
576
+
562
577
ret = vk_create_sampler( //
563
578
vk, // vk_bundle
564
579
VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, // clamp_mode
565
580
&r->samplers.clamp_to_edge); // out_sampler
566
581
VK_CHK_WITH_RET(ret, "vk_create_sampler", false);
567
582
583
+
VK_NAME_OBJECT(vk, SAMPLER, r->samplers.clamp_to_edge, "render_resources sampler clamp_to_edge");
584
+
568
585
ret = vk_create_sampler( //
569
586
vk, // vk_bundle
570
587
VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER, // clamp_mode
571
588
&r->samplers.clamp_to_border_black); // out_sampler
572
589
VK_CHK_WITH_RET(ret, "vk_create_sampler", false);
590
+
591
+
VK_NAME_OBJECT(vk, SAMPLER, r->samplers.clamp_to_border_black,
592
+
"render_resources sampler clamp_to_border_black");
573
593
574
594
575
595
/*
···
579
599
ret = vk_cmd_pool_init(vk, &r->distortion_pool, VK_COMMAND_POOL_CREATE_TRANSIENT_BIT);
580
600
VK_CHK_WITH_RET(ret, "vk_cmd_pool_init", false);
581
601
602
+
VK_NAME_OBJECT(vk, COMMAND_POOL, r->distortion_pool.pool, "render_resources distortion command pool");
603
+
582
604
VkCommandPoolCreateInfo command_pool_info = {
583
605
.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,
584
606
.flags = VK_COMMAND_POOL_CREATE_TRANSIENT_BIT,
···
587
609
588
610
ret = vk->vkCreateCommandPool(vk->device, &command_pool_info, NULL, &r->cmd_pool);
589
611
VK_CHK_WITH_RET(ret, "vkCreateCommandPool", false);
612
+
613
+
VK_NAME_OBJECT(vk, COMMAND_POOL, r->cmd_pool, "render_resources command pool");
590
614
591
615
592
616
/*
···
615
639
&r->mock.color.image); // out_image
616
640
VK_CHK_WITH_RET(ret, "vk_create_image_simple", false);
617
641
642
+
VK_NAME_OBJECT(vk, DEVICE_MEMORY, r->mock.color.memory, "render_resources mock color device memory");
643
+
VK_NAME_OBJECT(vk, IMAGE, r->mock.color.image, "render_resources mock color image");
644
+
618
645
ret = vk_create_view( //
619
646
vk, // vk_bundle
620
647
r->mock.color.image, // image
···
624
651
&r->mock.color.image_view); // out_view
625
652
VK_CHK_WITH_RET(ret, "vk_create_view", false);
626
653
654
+
VK_NAME_OBJECT(vk, IMAGE_VIEW, r->mock.color.image_view, "render_resources mock color image view");
655
+
627
656
628
657
VkCommandBuffer cmd = VK_NULL_HANDLE;
629
658
ret = vk_cmd_create_and_begin_cmd_buffer_locked(vk, r->cmd_pool, 0, &cmd);
630
659
VK_CHK_WITH_RET(ret, "vk_cmd_create_and_begin_cmd_buffer_locked", false);
631
660
661
+
VK_NAME_OBJECT(vk, COMMAND_BUFFER, cmd, "render_resources mock command buffer");
662
+
632
663
ret = prepare_mock_image_locked( //
633
664
vk, // vk_bundle
634
665
cmd, // cmd
···
649
680
ret = vk_create_pipeline_cache(vk, &r->pipeline_cache);
650
681
VK_CHK_WITH_RET(ret, "vk_create_pipeline_cache", false);
651
682
683
+
VK_NAME_OBJECT(vk, PIPELINE_CACHE, r->pipeline_cache, "render_resources pipeline cache");
684
+
652
685
VkCommandBufferAllocateInfo cmd_buffer_info = {
653
686
.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,
654
687
.commandPool = r->cmd_pool,
···
661
694
&cmd_buffer_info, // pAllocateInfo
662
695
&r->cmd); // pCommandBuffers
663
696
VK_CHK_WITH_RET(ret, "vkAllocateCommandBuffers", false);
697
+
698
+
VK_NAME_OBJECT(vk, COMMAND_BUFFER, r->cmd, "render_resources command buffer");
664
699
665
700
666
701
/*
···
689
724
&r->gfx.ubo_and_src_descriptor_pool); // out_descriptor_pool
690
725
VK_CHK_WITH_RET(ret, "vk_create_descriptor_pool", false);
691
726
727
+
VK_NAME_OBJECT(vk, DESCRIPTOR_POOL, r->gfx.ubo_and_src_descriptor_pool,
728
+
"render_resources ubo and src descriptor pool");
729
+
692
730
VkBufferUsageFlags usage_flags = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT;
693
731
VkMemoryPropertyFlags memory_property_flags = //
694
732
VK_MEMORY_PROPERTY_HOST_COHERENT_BIT | //
···
715
753
memory_property_flags, // memory_property_flags
716
754
size); // size
717
755
VK_CHK_WITH_RET(ret, "render_buffer_init", false);
756
+
VK_NAME_OBJECT(vk, BUFFER, r->gfx.shared_ubo.buffer, "render_resources gfx shared ubo");
718
757
719
758
ret = render_buffer_map( //
720
759
vk, // vk_bundle
···
734
773
&r->gfx.layer.shared.descriptor_set_layout); // out_descriptor_set_layout
735
774
VK_CHK_WITH_RET(ret, "create_gfx_ubo_and_src_descriptor_set_layout", false);
736
775
776
+
VK_NAME_OBJECT(vk, DESCRIPTOR_SET_LAYOUT, r->gfx.layer.shared.descriptor_set_layout,
777
+
"render_resources gfx layer shared descriptor set layout");
778
+
737
779
ret = vk_create_pipeline_layout( //
738
780
vk, // vk_bundle
739
781
r->gfx.layer.shared.descriptor_set_layout, // descriptor_set_layout
740
782
&r->gfx.layer.shared.pipeline_layout); // out_pipeline_layout
741
783
VK_CHK_WITH_RET(ret, "vk_create_pipeline_layout", false);
784
+
785
+
VK_NAME_OBJECT(vk, PIPELINE_LAYOUT, r->gfx.layer.shared.pipeline_layout,
786
+
"render_resources gfx layer shared pipeline layout");
742
787
743
788
744
789
/*
···
752
797
&r->mesh.descriptor_set_layout); // out_mesh_descriptor_set_layout
753
798
VK_CHK_WITH_RET(ret, "create_gfx_ubo_and_src_descriptor_set_layout", false);
754
799
800
+
VK_NAME_OBJECT(vk, DESCRIPTOR_SET_LAYOUT, r->mesh.descriptor_set_layout,
801
+
"render_resources mesh descriptor set layout");
802
+
755
803
ret = vk_create_pipeline_layout( //
756
804
vk, // vk_bundle
757
805
r->mesh.descriptor_set_layout, // descriptor_set_layout
758
806
&r->mesh.pipeline_layout); // out_pipeline_layout
759
807
VK_CHK_WITH_RET(ret, "vk_create_pipeline_layout", false);
808
+
809
+
VK_NAME_OBJECT(vk, PIPELINE_LAYOUT, r->mesh.pipeline_layout, "render_resources mesh pipeline layout");
760
810
761
811
bret = init_mesh_vertex_buffers( //
762
812
vk, //
···
808
858
&r->compute.descriptor_pool); // out_descriptor_pool
809
859
VK_CHK_WITH_RET(ret, "vk_create_descriptor_pool", false);
810
860
861
+
VK_NAME_OBJECT(vk, DESCRIPTOR_POOL, r->compute.descriptor_pool, "render_resources compute descriptor pool");
811
862
812
863
/*
813
864
* Layer pipeline
···
822
873
&r->compute.layer.descriptor_set_layout); // out_descriptor_set_layout
823
874
VK_CHK_WITH_RET(ret, "create_compute_layer_descriptor_set_layout", false);
824
875
876
+
VK_NAME_OBJECT(vk, DESCRIPTOR_SET_LAYOUT, r->compute.layer.descriptor_set_layout,
877
+
"render_resources compute layer descriptor set layout");
878
+
825
879
ret = vk_create_pipeline_layout( //
826
880
vk, // vk_bundle
827
881
r->compute.layer.descriptor_set_layout, // descriptor_set_layout
828
882
&r->compute.layer.pipeline_layout); // out_pipeline_layout
829
883
VK_CHK_WITH_RET(ret, "vk_create_pipeline_layout", false);
830
884
885
+
VK_NAME_OBJECT(vk, PIPELINE_LAYOUT, r->compute.layer.pipeline_layout,
886
+
"render_resources compute layer pipeline layout");
887
+
831
888
struct compute_layer_params layer_params = {
832
889
.do_timewarp = false,
833
890
.do_color_correction = true,
···
843
900
&layer_params, // params
844
901
&r->compute.layer.non_timewarp_pipeline); // out_compute_pipeline
845
902
VK_CHK_WITH_RET(ret, "create_compute_layer_pipeline", false);
903
+
904
+
VK_NAME_OBJECT(vk, PIPELINE, r->compute.layer.non_timewarp_pipeline,
905
+
"render_resources compute layer non timewarp pipeline");
846
906
847
907
struct compute_layer_params layer_timewarp_params = {
848
908
.do_timewarp = true,
···
860
920
&r->compute.layer.timewarp_pipeline); // out_compute_pipeline
861
921
VK_CHK_WITH_RET(ret, "create_compute_layer_pipeline", false);
862
922
923
+
VK_NAME_OBJECT(vk, PIPELINE, r->compute.layer.timewarp_pipeline,
924
+
"render_resources compute layer timewarp pipeline");
925
+
863
926
size_t layer_ubo_size = sizeof(struct render_compute_layer_ubo_data);
864
927
865
928
for (uint32_t i = 0; i < ARRAY_SIZE(r->compute.layer.ubos); i++) {
···
870
933
memory_property_flags, // memory_property_flags
871
934
layer_ubo_size); // size
872
935
VK_CHK_WITH_RET(ret, "render_buffer_init", false);
936
+
VK_NAME_OBJECT(vk, BUFFER, r->compute.layer.ubos[i].buffer, "render_resources compute layer ubo");
873
937
874
938
ret = render_buffer_map( //
875
939
vk, // vk_bundle
···
891
955
&r->compute.distortion.descriptor_set_layout); // out_descriptor_set_layout
892
956
VK_CHK_WITH_RET(ret, "create_compute_distortion_descriptor_set_layout", false);
893
957
958
+
VK_NAME_OBJECT(vk, DESCRIPTOR_SET_LAYOUT, r->compute.distortion.descriptor_set_layout,
959
+
"render_resources compute distortion descriptor set layout");
960
+
894
961
ret = vk_create_pipeline_layout( //
895
962
vk, // vk_bundle
896
963
r->compute.distortion.descriptor_set_layout, // descriptor_set_layout
897
964
&r->compute.distortion.pipeline_layout); // out_pipeline_layout
898
965
VK_CHK_WITH_RET(ret, "vk_create_pipeline_layout", false);
966
+
967
+
VK_NAME_OBJECT(vk, PIPELINE_LAYOUT, r->compute.distortion.pipeline_layout,
968
+
"render_resources compute distortion pipeline layout");
899
969
900
970
struct compute_distortion_params distortion_params = {
901
971
.distortion_texel_count = RENDER_DISTORTION_IMAGE_DIMENSIONS,
···
911
981
&r->compute.distortion.pipeline); // out_compute_pipeline
912
982
VK_CHK_WITH_RET(ret, "create_compute_distortion_pipeline", false);
913
983
984
+
VK_NAME_OBJECT(vk, PIPELINE, r->compute.distortion.pipeline, "render_resources compute distortion pipeline");
985
+
914
986
struct compute_distortion_params distortion_timewarp_params = {
915
987
.distortion_texel_count = RENDER_DISTORTION_IMAGE_DIMENSIONS,
916
988
.do_timewarp = true,
···
924
996
&distortion_timewarp_params, // params
925
997
&r->compute.distortion.timewarp_pipeline); // out_compute_pipeline
926
998
VK_CHK_WITH_RET(ret, "create_compute_distortion_pipeline", false);
999
+
1000
+
VK_NAME_OBJECT(vk, PIPELINE, r->compute.distortion.timewarp_pipeline,
1001
+
"render_resources compute distortion timewarp pipeline");
927
1002
928
1003
size_t distortion_ubo_size = sizeof(struct render_compute_distortion_ubo_data);
929
1004
···
934
1009
memory_property_flags, // memory_property_flags
935
1010
distortion_ubo_size); // size
936
1011
VK_CHK_WITH_RET(ret, "render_buffer_init", false);
1012
+
VK_NAME_OBJECT(vk, BUFFER, r->compute.distortion.ubo.buffer, "render_resources compute distortion ubo");
937
1013
ret = render_buffer_map( //
938
1014
vk, // vk_bundle
939
1015
&r->compute.distortion.ubo); // buffer
···
953
1029
&r->compute.clear.pipeline); // out_compute_pipeline
954
1030
VK_CHK_WITH_RET(ret, "vk_create_compute_pipeline", false);
955
1031
1032
+
VK_NAME_OBJECT(vk, PIPELINE, r->compute.clear.pipeline, "render_resources compute clear pipeline");
1033
+
956
1034
size_t clear_ubo_size = sizeof(struct render_compute_distortion_ubo_data);
957
1035
958
1036
ret = render_buffer_init( //
···
962
1040
memory_property_flags, // memory_property_flags
963
1041
clear_ubo_size); // size
964
1042
VK_CHK_WITH_RET(ret, "render_buffer_init", false);
1043
+
VK_NAME_OBJECT(vk, BUFFER, r->compute.clear.ubo.buffer, "render_resources compute clear ubo");
965
1044
966
1045
ret = render_buffer_map( //
967
1046
vk, // vk_bundle
···
1003
1082
NULL, // pAllocator
1004
1083
&r->query_pool); // pQueryPool
1005
1084
1085
+
VK_NAME_OBJECT(vk, QUERY_POOL, r->query_pool, "render_resources query pool");
1006
1086
1007
1087
/*
1008
1088
* Done