1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314
1315
1316
1317
1318
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328
1329
1330
1331
1332
1333
1334
1335
1336
1337
1338
1339
1340
1341
1342
1343
1344
1345
1346
1347
1348
1349
1350
1351
1352
1353
1354
1355
1356
1357
1358
|
#pragma once
#include "dxvk_barrier.h"
#include "dxvk_bind_mask.h"
#include "dxvk_cmdlist.h"
#include "dxvk_context_state.h"
#include "dxvk_data.h"
#include "dxvk_objects.h"
#include "dxvk_resource.h"
#include "dxvk_util.h"
namespace dxvk {
/**
* \brief DXVk context
*
* Tracks pipeline state and records command lists.
* This is where the actual rendering commands are
* recorded.
*/
class DxvkContext : public RcObject {
public:
DxvkContext(const Rc<DxvkDevice>& device);
~DxvkContext();
/**
* \brief Begins command buffer recording
*
* Begins recording a command list. This does
* not alter any context state other than the
* active command list.
* \param [in] cmdList Target command list
*/
void beginRecording(
const Rc<DxvkCommandList>& cmdList);
/**
* \brief Ends command buffer recording
*
* Finishes recording the active command list.
* The command list can then be submitted to
* the device.
*
* This will not change any context state
* other than the active command list.
* \returns Active command list
*/
Rc<DxvkCommandList> endRecording();
/**
* \brief Flushes command buffer
*
* Transparently submits the current command
* buffer and allocates a new one.
*/
void flushCommandList();
/**
* \brief Begins generating query data
* \param [in] query The query to end
*/
void beginQuery(
const Rc<DxvkGpuQuery>& query);
/**
* \brief Ends generating query data
* \param [in] query The query to end
*/
void endQuery(
const Rc<DxvkGpuQuery>& query);
/**
* \brief Sets render targets
*
* Creates a framebuffer on the fly if necessary
* and binds it using \c bindFramebuffer.
* \param [in] targets Render targets to bind
*/
void bindRenderTargets(
const DxvkRenderTargets& targets);
/**
* \brief Binds indirect argument buffer
*
* Sets the buffers that are going to be used
* for indirect draw and dispatch operations.
* \param [in] argBuffer New argument buffer
* \param [in] cntBuffer New count buffer
*/
void bindDrawBuffers(
const DxvkBufferSlice& argBuffer,
const DxvkBufferSlice& cntBuffer);
/**
* \brief Binds index buffer
*
* The index buffer will be used when
* issuing \c drawIndexed commands.
* \param [in] buffer New index buffer
* \param [in] indexType Index type
*/
void bindIndexBuffer(
const DxvkBufferSlice& buffer,
VkIndexType indexType);
/**
* \brief Binds buffer as a shader resource
*
* Can be used for uniform and storage buffers.
* \param [in] slot Resource binding slot
* \param [in] buffer Buffer to bind
*/
void bindResourceBuffer(
uint32_t slot,
const DxvkBufferSlice& buffer);
/**
* \brief Binds image or buffer view
*
* Can be used for sampled images with a dedicated
* sampler and for storage images, as well as for
* uniform texel buffers and storage texel buffers.
* \param [in] slot Resource binding slot
* \param [in] imageView Image view to bind
* \param [in] bufferView Buffer view to bind
*/
void bindResourceView(
uint32_t slot,
const Rc<DxvkImageView>& imageView,
const Rc<DxvkBufferView>& bufferView);
/**
* \brief Binds image sampler
*
* Binds a sampler that can be used together with
* an image in order to read from a texture.
* \param [in] slot Resource binding slot
* \param [in] sampler Sampler view to bind
*/
void bindResourceSampler(
uint32_t slot,
const Rc<DxvkSampler>& sampler);
/**
* \brief Binds a shader to a given state
*
* \param [in] stage Target shader stage
* \param [in] shader The shader to bind
*/
void bindShader(
VkShaderStageFlagBits stage,
const Rc<DxvkShader>& shader);
/**
* \brief Binds vertex buffer
*
* \param [in] binding Vertex buffer binding
* \param [in] buffer New vertex buffer
* \param [in] stride Stride between vertices
*/
void bindVertexBuffer(
uint32_t binding,
const DxvkBufferSlice& buffer,
uint32_t stride);
/**
* \brief Binds transform feedback buffer
*
* \param [in] binding Xfb buffer binding
* \param [in] buffer The buffer to bind
* \param [in] counter Xfb counter buffer
*/
void bindXfbBuffer(
uint32_t binding,
const DxvkBufferSlice& buffer,
const DxvkBufferSlice& counter);
/**
* \brief Blits an image
*
* \param [in] dstImage Destination image
* \param [in] dstMapping Destination swizzle
* \param [in] srcImage Source image
* \param [in] srcMapping Source swizzle
* \param [in] region Blit region
* \param [in] filter Texture filter
*/
void blitImage(
const Rc<DxvkImage>& dstImage,
const VkComponentMapping& dstMapping,
const Rc<DxvkImage>& srcImage,
const VkComponentMapping& srcMapping,
const VkImageBlit& region,
VkFilter filter);
/**
* \brief Changes image layout
*
* Permanently changes the layout for a given
* image. Immediately performs the transition.
* \param [in] image The image to transition
* \param [in] layout New image layout
*/
void changeImageLayout(
const Rc<DxvkImage>& image,
VkImageLayout layout);
/**
* \brief Clears a buffer with a fixed value
*
* Note that both \c offset and \c length must
* be multiples of four, and that \c value is
* consumed as a four-byte word.
* \param [in] buffer The buffer to clear
* \param [in] offset Offset of the range to clear
* \param [in] length Bumber of bytes to clear
* \param [in] value Clear value
*/
void clearBuffer(
const Rc<DxvkBuffer>& buffer,
VkDeviceSize offset,
VkDeviceSize length,
uint32_t value);
/**
* \brief Clears a buffer view
*
* Unlike \c clearBuffer, this method can be used
* to clear a buffer view with format conversion.
* \param [in] bufferView The buffer view
* \param [in] offset Offset of the region to clear
* \param [in] length Extent of the region to clear
* \param [in] value The clear value
*/
void clearBufferView(
const Rc<DxvkBufferView>& bufferView,
VkDeviceSize offset,
VkDeviceSize length,
VkClearColorValue value);
/**
* \brief Clears subresources of a color image
*
* \param [in] image The image to clear
* \param [in] value Clear value
* \param [in] subresources Subresources to clear
*/
void clearColorImage(
const Rc<DxvkImage>& image,
const VkClearColorValue& value,
const VkImageSubresourceRange& subresources);
/**
* \brief Clears subresources of a depth-stencil image
*
* \param [in] image The image to clear
* \param [in] value Clear value
* \param [in] subresources Subresources to clear
*/
void clearDepthStencilImage(
const Rc<DxvkImage>& image,
const VkClearDepthStencilValue& value,
const VkImageSubresourceRange& subresources);
/**
* \brief Clears a compressed image to black
*
* \param [in] image The image to clear
* \param [in] subresources Subresources to clear
*/
void clearCompressedColorImage(
const Rc<DxvkImage>& image,
const VkImageSubresourceRange& subresources);
/**
* \brief Clears an active render target
*
* \param [in] imageView Render target view to clear
* \param [in] clearAspects Image aspects to clear
* \param [in] clearValue The clear value
*/
void clearRenderTarget(
const Rc<DxvkImageView>& imageView,
VkImageAspectFlags clearAspects,
VkClearValue clearValue);
/**
* \brief Clears an image view
*
* Can be used to clear sub-regions of storage images
* that are not going to be used as render targets.
* Implicit format conversion will be applied.
* \param [in] imageView The image view
* \param [in] offset Offset of the rect to clear
* \param [in] extent Extent of the rect to clear
* \param [in] aspect Aspect mask to clear
* \param [in] value The clear value
*/
void clearImageView(
const Rc<DxvkImageView>& imageView,
VkOffset3D offset,
VkExtent3D extent,
VkImageAspectFlags aspect,
VkClearValue value);
/**
* \brief Copies data from one buffer to another
*
* \param [in] dstBuffer Destination buffer
* \param [in] dstOffset Destination data offset
* \param [in] srcBuffer Source buffer
* \param [in] srcOffset Source data offset
* \param [in] numBytes Number of bytes to copy
*/
void copyBuffer(
const Rc<DxvkBuffer>& dstBuffer,
VkDeviceSize dstOffset,
const Rc<DxvkBuffer>& srcBuffer,
VkDeviceSize srcOffset,
VkDeviceSize numBytes);
/**
* \brief Copies overlapping buffer region
*
* Can be used to copy potentially overlapping
* buffer regions within the same buffer. If
* the source and destination regions do not
* overlap, it will behave as \ref copyBuffer.
* \param [in] dstBuffer The buffer
* \param [in] dstOffset Offset of target region
* \param [in] srcOffset Offset of source region
* \param [in] numBytes Number of bytes to copy
*/
void copyBufferRegion(
const Rc<DxvkBuffer>& dstBuffer,
VkDeviceSize dstOffset,
VkDeviceSize srcOffset,
VkDeviceSize numBytes);
/**
* \brief Copies data from a buffer to an image
*
* Source data must be packed, except for the row alignment.
* \param [in] dstImage Destination image
* \param [in] dstSubresource Destination subresource
* \param [in] dstOffset Destination area offset
* \param [in] dstExtent Destination area size
* \param [in] srcBuffer Source buffer
* \param [in] srcOffset Source offset, in bytes
* \param [in] rowAlignment Row alignment, in bytes
* \param [in] sliceAlignment Slice alignment, in bytes
*/
void copyBufferToImage(
const Rc<DxvkImage>& dstImage,
VkImageSubresourceLayers dstSubresource,
VkOffset3D dstOffset,
VkExtent3D dstExtent,
const Rc<DxvkBuffer>& srcBuffer,
VkDeviceSize srcOffset,
VkDeviceSize rowAlignment,
VkDeviceSize sliceAlignment);
/**
* \brief Copies data from one image to another
*
* \param [in] dstImage Destination image
* \param [in] dstSubresource Destination subresource
* \param [in] dstOffset Destination area offset
* \param [in] srcImage Source image
* \param [in] srcSubresource Source subresource
* \param [in] srcOffset Source area offset
* \param [in] extent Size of the area to copy
*/
void copyImage(
const Rc<DxvkImage>& dstImage,
VkImageSubresourceLayers dstSubresource,
VkOffset3D dstOffset,
const Rc<DxvkImage>& srcImage,
VkImageSubresourceLayers srcSubresource,
VkOffset3D srcOffset,
VkExtent3D extent);
/**
* \brief Copies overlapping image region
*
* \param [in] dstImage The image
* \param [in] dstSubresource The image subresource
* \param [in] dstOffset Destination region offset
* \param [in] srcOffset Source region offset
* \param [in] extent Size of the copy region
*/
void copyImageRegion(
const Rc<DxvkImage>& dstImage,
VkImageSubresourceLayers dstSubresource,
VkOffset3D dstOffset,
VkOffset3D srcOffset,
VkExtent3D extent);
/**
* \brief Copies data from an image into a buffer
*
* \param [in] dstBuffer Destination buffer
* \param [in] dstOffset Destination offset, in bytes
* \param [in] dstExtent Destination data extent
* \param [in] rowAlignment Row alignment, in bytes
* \param [in] sliceAlignment Slice alignment, in bytes
* \param [in] srcImage Source image
* \param [in] srcSubresource Source subresource
* \param [in] srcOffset Source area offset
* \param [in] srcExtent Source area size
*/
void copyImageToBuffer(
const Rc<DxvkBuffer>& dstBuffer,
VkDeviceSize dstOffset,
VkDeviceSize rowAlignment,
VkDeviceSize sliceAlignment,
const Rc<DxvkImage>& srcImage,
VkImageSubresourceLayers srcSubresource,
VkOffset3D srcOffset,
VkExtent3D srcExtent);
/**
* \brief Packs depth-stencil image data to a buffer
*
* Packs data from both the depth and stencil aspects
* of an image into a buffer. The supported formats are:
* - \c VK_FORMAT_D24_UNORM_S8_UINT: 0xssdddddd
* - \c VK_FORMAT_D32_SFLOAT_S8_UINT: 0xdddddddd 0x000000ss
* \param [in] dstBuffer Destination buffer
* \param [in] dstBufferOffset Destination offset, in bytes
* \param [in] dstOffset Destination image offset
* \param [in] dstSize Destination image size
* \param [in] srcImage Source image
* \param [in] srcSubresource Source subresource
* \param [in] srcOffset Source area offset
* \param [in] srcExtent Source area size
* \param [in] format Packed data format
*/
void copyDepthStencilImageToPackedBuffer(
const Rc<DxvkBuffer>& dstBuffer,
VkDeviceSize dstBufferOffset,
VkOffset2D dstOffset,
VkExtent2D dstExtent,
const Rc<DxvkImage>& srcImage,
VkImageSubresourceLayers srcSubresource,
VkOffset2D srcOffset,
VkExtent2D srcExtent,
VkFormat format);
/**
* \brief Copies image data stored in a linear buffer to another
*
* The source and destination regions may overlap, in which case
* a temporary copy of the source buffer will be created.
* \param [in] dstBuffer Destination buffer
* \param [in] dstBufferOffset Destination subresource offset
* \param [in] dstOffset Destination image offset
* \param [in] dstSize Total size of the destination image
* \param [in] srcBuffer Source buffer
* \param [in] srcBufferOffset Source subresource offset
* \param [in] srcOffset Source image offset
* \param [in] srcSize Total size of the source image
* \param [in] extent Number of pixels to copy
* \param [in] elementSize Pixel size, in bytes
*/
void copyPackedBufferImage(
const Rc<DxvkBuffer>& dstBuffer,
VkDeviceSize dstBufferOffset,
VkOffset3D dstOffset,
VkExtent3D dstSize,
const Rc<DxvkBuffer>& srcBuffer,
VkDeviceSize srcBufferOffset,
VkOffset3D srcOffset,
VkExtent3D srcSize,
VkExtent3D extent,
VkDeviceSize elementSize);
/**
* \brief Unpacks buffer data to a depth-stencil image
*
* Writes the packed depth-stencil data to an image.
* See \ref copyDepthStencilImageToPackedBuffer for
* which formats are supported and how they are packed.
* \param [in] dstImage Destination image
* \param [in] dstSubresource Destination subresource
* \param [in] dstOffset Image area offset
* \param [in] dstExtent Image area size
* \param [in] srcBuffer Packed data buffer
* \param [in] srcBufferOffset Buffer offset of source image
* \param [in] srcOffset Offset into the source image
* \param [in] srcExtent Total size of the source image
* \param [in] format Packed data format
*/
void copyPackedBufferToDepthStencilImage(
const Rc<DxvkImage>& dstImage,
VkImageSubresourceLayers dstSubresource,
VkOffset2D dstOffset,
VkExtent2D dstExtent,
const Rc<DxvkBuffer>& srcBuffer,
VkDeviceSize srcBufferOffset,
VkOffset2D srcOffset,
VkExtent2D srcExtent,
VkFormat format);
/**
* \brief Discards a buffer
*
* Renames the buffer in case it is currently
* used by the GPU in order to avoid having to
* insert barriers before future commands using
* the buffer.
* \param [in] buffer The buffer to discard
*/
void discardBuffer(
const Rc<DxvkBuffer>& buffer);
/**
* \brief Discards contents of an image view
*
* Discards the current contents of the image
* and performs a fast layout transition. This
* may improve performance in some cases.
* \param [in] imageView View to discard
* \param [in] discardAspects Image aspects to discard
*/
void discardImageView(
const Rc<DxvkImageView>& imageView,
VkImageAspectFlags discardAspects);
/**
* \brief Starts compute jobs
*
* \param [in] x Number of threads in X direction
* \param [in] y Number of threads in Y direction
* \param [in] z Number of threads in Z direction
*/
void dispatch(
uint32_t x,
uint32_t y,
uint32_t z);
/**
* \brief Indirect dispatch call
*
* Takes arguments from a buffer. The buffer must contain
* a structure of the type \c VkDispatchIndirectCommand.
* \param [in] offset Draw buffer offset
*/
void dispatchIndirect(
VkDeviceSize offset);
/**
* \brief Draws primitive without using an index buffer
*
* \param [in] vertexCount Number of vertices to draw
* \param [in] instanceCount Number of instances to render
* \param [in] firstVertex First vertex in vertex buffer
* \param [in] firstInstance First instance ID
*/
void draw(
uint32_t vertexCount,
uint32_t instanceCount,
uint32_t firstVertex,
uint32_t firstInstance);
/**
* \brief Indirect draw call
*
* Takes arguments from a buffer. The structure stored
* in the buffer must be of type \c VkDrawIndirectCommand.
* \param [in] offset Draw buffer offset
* \param [in] count Number of draws
* \param [in] stride Stride between dispatch calls
*/
void drawIndirect(
VkDeviceSize offset,
uint32_t count,
uint32_t stride);
/**
* \brief Indirect draw call
*
* Takes arguments from a buffer. The structure stored
* in the buffer must be of type \c VkDrawIndirectCommand.
* \param [in] offset Draw buffer offset
* \param [in] countOffset Draw count offset
* \param [in] maxCount Maximum number of draws
* \param [in] stride Stride between dispatch calls
*/
void drawIndirectCount(
VkDeviceSize offset,
VkDeviceSize countOffset,
uint32_t maxCount,
uint32_t stride);
/**
* \brief Draws primitives using an index buffer
*
* \param [in] indexCount Number of indices to draw
* \param [in] instanceCount Number of instances to render
* \param [in] firstIndex First index within the index buffer
* \param [in] vertexOffset Vertex ID that corresponds to index 0
* \param [in] firstInstance First instance ID
*/
void drawIndexed(
uint32_t indexCount,
uint32_t instanceCount,
uint32_t firstIndex,
uint32_t vertexOffset,
uint32_t firstInstance);
/**
* \brief Indirect indexed draw call
*
* Takes arguments from a buffer. The structure type for
* the draw buffer is \c VkDrawIndexedIndirectCommand.
* \param [in] offset Draw buffer offset
* \param [in] count Number of draws
* \param [in] stride Stride between dispatch calls
*/
void drawIndexedIndirect(
VkDeviceSize offset,
uint32_t count,
uint32_t stride);
/**
* \brief Indirect indexed draw call
*
* Takes arguments from a buffer. The structure type for
* the draw buffer is \c VkDrawIndexedIndirectCommand.
* \param [in] offset Draw buffer offset
* \param [in] countOffset Draw count offset
* \param [in] maxCount Maximum number of draws
* \param [in] stride Stride between dispatch calls
*/
void drawIndexedIndirectCount(
VkDeviceSize offset,
VkDeviceSize countOffset,
uint32_t maxCount,
uint32_t stride);
/**
* \brief Transform feddback draw call
* \param [in] counterBuffer Xfb counter buffer
* \param [in] counterDivisor Vertex stride
* \param [in] counterBias Counter bias
*/
void drawIndirectXfb(
const DxvkBufferSlice& counterBuffer,
uint32_t counterDivisor,
uint32_t counterBias);
/**
* \brief Emits barrier for render target readback
*
* Use between draw calls if the fragment shader
* reads one of the currently bound render targets.
*/
void emitRenderTargetReadbackBarrier();
/**
* \brief Generates mip maps
*
* Uses blitting to generate lower mip levels from
* the top-most mip level passed to this method.
* \param [in] imageView The image to generate mips for
* \param [in] filter The filter to use for generation
*/
void generateMipmaps(
const Rc<DxvkImageView>& imageView,
VkFilter filter);
/**
* \brief Initializes or invalidates an image
*
* Sets up the image layout for future operations
* while discarding any previous contents.
* \param [in] image The image to initialize
* \param [in] subresources Image subresources
* \param [in] initialLayout Initial image layout
*/
void initImage(
const Rc<DxvkImage>& image,
const VkImageSubresourceRange& subresources,
VkImageLayout initialLayout);
/**
* \brief Invalidates a buffer's contents
*
* Discards a buffer's contents by replacing the
* backing resource. This allows the host to access
* the buffer while the GPU is still accessing the
* original backing resource.
*
* \warning If the buffer is used by another context,
* invalidating it will result in undefined behaviour.
* \param [in] buffer The buffer to invalidate
* \param [in] slice New buffer slice handle
*/
void invalidateBuffer(
const Rc<DxvkBuffer>& buffer,
const DxvkBufferSliceHandle& slice);
/**
* \brief Updates push constants
*
* Updates the given push constant range.
* \param [in] offset Byte offset of data to update
* \param [in] size Number of bytes to update
* \param [in] data Pointer to raw data
*/
void pushConstants(
uint32_t offset,
uint32_t size,
const void* data);
/**
* \brief Resolves a multisampled image resource
*
* Resolves a multisampled image into a non-multisampled
* image. The subresources of both images must have the
* same size and compatible formats.
* A format can be specified for the resolve operation.
* If it is \c VK_FORMAT_UNDEFINED, the resolve operation
* will use the source image format.
* \param [in] dstImage Destination image
* \param [in] srcImage Source image
* \param [in] region Region to resolve
* \param [in] format Format for the resolve operation
*/
void resolveImage(
const Rc<DxvkImage>& dstImage,
const Rc<DxvkImage>& srcImage,
const VkImageResolve& region,
VkFormat format);
/**
* \brief Resolves a multisampled depth-stencil resource
*
* \param [in] dstImage Destination image
* \param [in] srcImage Source image
* \param [in] region Region to resolve
* \param [in] depthMode Resolve mode for depth aspect
* \param [in] stencilMode Resolve mode for stencil aspect
*/
void resolveDepthStencilImage(
const Rc<DxvkImage>& dstImage,
const Rc<DxvkImage>& srcImage,
const VkImageResolve& region,
VkResolveModeFlagBitsKHR depthMode,
VkResolveModeFlagBitsKHR stencilMode);
/**
* \brief Transforms image subresource layouts
*
* \param [in] dstImage Image to transform
* \param [in] dstSubresources Subresources
* \param [in] srcLayout Current layout
* \param [in] dstLayout Desired layout
*/
void transformImage(
const Rc<DxvkImage>& dstImage,
const VkImageSubresourceRange& dstSubresources,
VkImageLayout srcLayout,
VkImageLayout dstLayout);
/**
* \brief Updates a buffer
*
* Copies data from the host into a buffer.
* \param [in] buffer Destination buffer
* \param [in] offset Offset of sub range to update
* \param [in] size Length of sub range to update
* \param [in] data Data to upload
*/
void updateBuffer(
const Rc<DxvkBuffer>& buffer,
VkDeviceSize offset,
VkDeviceSize size,
const void* data);
/**
* \brief Updates an image
*
* Copies data from the host into an image.
* \param [in] image Destination image
* \param [in] subsresources Image subresources to update
* \param [in] imageOffset Offset of the image area to update
* \param [in] imageExtent Size of the image area to update
* \param [in] data Source data
* \param [in] pitchPerRow Row pitch of the source data
* \param [in] pitchPerLayer Layer pitch of the source data
*/
void updateImage(
const Rc<DxvkImage>& image,
const VkImageSubresourceLayers& subresources,
VkOffset3D imageOffset,
VkExtent3D imageExtent,
const void* data,
VkDeviceSize pitchPerRow,
VkDeviceSize pitchPerLayer);
/**
* \brief Updates an depth-stencil image
*
* \param [in] image Destination image
* \param [in] subsresources Image subresources to update
* \param [in] imageOffset Offset of the image area to update
* \param [in] imageExtent Size of the image area to update
* \param [in] data Source data
* \param [in] pitchPerRow Row pitch of the source data
* \param [in] pitchPerLayer Layer pitch of the source data
* \param [in] format Packed depth-stencil format
*/
void updateDepthStencilImage(
const Rc<DxvkImage>& image,
const VkImageSubresourceLayers& subresources,
VkOffset2D imageOffset,
VkExtent2D imageExtent,
const void* data,
VkDeviceSize pitchPerRow,
VkDeviceSize pitchPerLayer,
VkFormat format);
/**
* \brief Uses transfer queue to initialize buffer
*
* Only safe to use if the buffer is not in use by the GPU.
* \param [in] buffer The buffer to initialize
* \param [in] data The data to copy to the buffer
*/
void uploadBuffer(
const Rc<DxvkBuffer>& buffer,
const void* data);
/**
* \brief Uses transfer queue to initialize image
*
* Only safe to use if the image is not in use by the GPU.
* \param [in] image The image to initialize
* \param [in] subresources Subresources to initialize
* \param [in] data Source data
* \param [in] pitchPerRow Row pitch of the source data
* \param [in] pitchPerLayer Layer pitch of the source data
*/
void uploadImage(
const Rc<DxvkImage>& image,
const VkImageSubresourceLayers& subresources,
const void* data,
VkDeviceSize pitchPerRow,
VkDeviceSize pitchPerLayer);
/**
* \brief Sets viewports
*
* \param [in] viewportCount Number of viewports
* \param [in] viewports The viewports
* \param [in] scissorRects Schissor rectangles
*/
void setViewports(
uint32_t viewportCount,
const VkViewport* viewports,
const VkRect2D* scissorRects);
/**
* \brief Sets blend constants
*
* Blend constants are a set of four floating
* point numbers that may be used as an input
* for blending operations.
* \param [in] blendConstants Blend constants
*/
void setBlendConstants(
DxvkBlendConstants blendConstants);
/**
* \brief Sets depth bias
*
* Depth bias has to be enabled explicitly in
* the rasterizer state to have any effect.
* \param [in] depthBias Depth bias values
*/
void setDepthBias(
DxvkDepthBias depthBias);
/**
* \brief Sets depth bounds
*
* Enables or disables the depth bounds test,
* and updates the values if necessary.
* \param [in] depthBounds Depth bounds
*/
void setDepthBounds(
DxvkDepthBounds depthBounds);
/**
* \brief Sets stencil reference
*
* Sets the reference value for stencil compare operations.
* \param [in] reference Reference value
*/
void setStencilReference(
uint32_t reference);
/**
* \brief Sets input assembly state
* \param [in] ia New state object
*/
void setInputAssemblyState(
const DxvkInputAssemblyState& ia);
/**
* \brief Sets input layout
*
* \param [in] attributeCount Number of vertex attributes
* \param [in] attributes The vertex attributes
* \param [in] bindingCount Number of buffer bindings
* \param [in] bindings Vertex buffer bindigs
*/
void setInputLayout(
uint32_t attributeCount,
const DxvkVertexAttribute* attributes,
uint32_t bindingCount,
const DxvkVertexBinding* bindings);
/**
* \brief Sets rasterizer state
* \param [in] rs New state object
*/
void setRasterizerState(
const DxvkRasterizerState& rs);
/**
* \brief Sets multisample state
* \param [in] ms New state object
*/
void setMultisampleState(
const DxvkMultisampleState& ms);
/**
* \brief Sets depth stencil state
* \param [in] ds New state object
*/
void setDepthStencilState(
const DxvkDepthStencilState& ds);
/**
* \brief Sets logic op state
* \param [in] lo New state object
*/
void setLogicOpState(
const DxvkLogicOpState& lo);
/**
* \brief Sets blend mode for an attachment
*
* \param [in] attachment The attachment index
* \param [in] blendMode The blend mode
*/
void setBlendMode(
uint32_t attachment,
const DxvkBlendMode& blendMode);
/**
* \brief Sets specialization constants
*
* Replaces current specialization constants with
* the given list of constant entries. The specId
* in the shader can be computed with \c getSpecId.
* \param [in] pipeline Graphics or Compute pipeline
* \param [in] index Constant index
* \param [in] value Constant value
*/
void setSpecConstant(
VkPipelineBindPoint pipeline,
uint32_t index,
uint32_t value);
/**
* \brief Sets barrier control flags
*
* Barrier control flags can be used to control
* implicit synchronization of compute shaders.
* \param [in] control New barrier control flags
*/
void setBarrierControl(
DxvkBarrierControlFlags control);
/**
* \brief Launches a Cuda kernel
*
* Since the kernel is launched with an opaque set of
* kernel-specific parameters which may reference
* resources bindlessly, such resources must be listed by
* the caller in the 'buffers' and 'images' parameters so
* that their access may be tracked appropriately.
* \param [in] nvxLaunchInfo Kernel launch parameter struct
* \param [in] buffers List of {buffer,read,write} used by kernel
* \param [in] images List of {image,read,write} used by kernel
*/
void launchCuKernelNVX(
const VkCuLaunchInfoNVX& nvxLaunchInfo,
const std::vector<std::pair<Rc<DxvkBuffer>, DxvkAccessFlags>>& buffers,
const std::vector<std::pair<Rc<DxvkImage>, DxvkAccessFlags>>& images);
/**
* \brief Signals a GPU event
* \param [in] event The event
*/
void signalGpuEvent(
const Rc<DxvkGpuEvent>& event);
/**
* \brief Writes to a timestamp query
* \param [in] query The timestamp query
*/
void writeTimestamp(
const Rc<DxvkGpuQuery>& query);
/**
* \brief Queues a signal
*
* The signal will be notified after all
* previously submitted commands have
* finished execution on the GPU.
* \param [in] signal The signal
* \param [in] value Signal value
*/
void signal(
const Rc<sync::Signal>& signal,
uint64_t value);
/**
* \brief Trims staging buffers
*
* Releases staging buffer resources. Calling
* this may be useful if data updates on a
* given context are rare.
*/
void trimStagingBuffers();
/**
* \brief Begins a debug label region
* \param [in] label The debug label
*
* Marks the start of a debug label region. Used by debugging/profiling
* tools to mark different workloads within a frame.
*/
void beginDebugLabel(VkDebugUtilsLabelEXT *label);
/**
* \brief Ends a debug label region
*
* Marks the close of a debug label region. Used by debugging/profiling
* tools to mark different workloads within a frame.
*/
void endDebugLabel();
/**
* \brief Inserts a debug label
* \param [in] label The debug label
*
* Inserts an instantaneous debug label. Used by debugging/profiling
* tools to mark different workloads within a frame.
*/
void insertDebugLabel(VkDebugUtilsLabelEXT *label);
private:
Rc<DxvkDevice> m_device;
DxvkObjects* m_common;
Rc<DxvkCommandList> m_cmd;
Rc<DxvkDescriptorPool> m_descPool;
Rc<DxvkBuffer> m_zeroBuffer;
DxvkContextFlags m_flags;
DxvkContextState m_state;
DxvkContextFeatures m_features;
DxvkBarrierSet m_sdmaAcquires;
DxvkBarrierSet m_sdmaBarriers;
DxvkBarrierSet m_initBarriers;
DxvkBarrierSet m_execAcquires;
DxvkBarrierSet m_execBarriers;
DxvkBarrierSet m_gfxBarriers;
DxvkBarrierControlFlags m_barrierControl;
DxvkGpuQueryManager m_queryManager;
DxvkStagingDataAlloc m_staging;
DxvkRenderTargetLayouts m_rtLayouts = { };
VkPipeline m_gpActivePipeline = VK_NULL_HANDLE;
VkPipeline m_cpActivePipeline = VK_NULL_HANDLE;
VkDescriptorSet m_gpSet = VK_NULL_HANDLE;
VkDescriptorSet m_cpSet = VK_NULL_HANDLE;
DxvkBindingSet<MaxNumVertexBindings + 1> m_vbTracked;
DxvkBindingSet<MaxNumResourceSlots> m_rcTracked;
std::vector<DxvkDeferredClear> m_deferredClears;
std::array<DxvkShaderResourceSlot, MaxNumResourceSlots> m_rc;
std::array<DxvkGraphicsPipeline*, 4096> m_gpLookupCache = { };
std::array<DxvkComputePipeline*, 256> m_cpLookupCache = { };
void blitImageFb(
const Rc<DxvkImage>& dstImage,
const Rc<DxvkImage>& srcImage,
const VkImageBlit& region,
const VkComponentMapping& mapping,
VkFilter filter);
void blitImageHw(
const Rc<DxvkImage>& dstImage,
const Rc<DxvkImage>& srcImage,
const VkImageBlit& region,
VkFilter filter);
template<bool ToImage>
void copyImageBufferData(
DxvkCmdBuffer cmd,
const Rc<DxvkImage>& image,
const VkImageSubresourceLayers& imageSubresource,
VkOffset3D imageOffset,
VkExtent3D imageExtent,
VkImageLayout imageLayout,
const DxvkBufferSliceHandle& bufferSlice,
VkDeviceSize bufferRowAlignment,
VkDeviceSize bufferSliceAlignment);
void copyImageHostData(
DxvkCmdBuffer cmd,
const Rc<DxvkImage>& image,
const VkImageSubresourceLayers& imageSubresource,
VkOffset3D imageOffset,
VkExtent3D imageExtent,
const void* hostData,
VkDeviceSize rowPitch,
VkDeviceSize slicePitch);
void clearImageViewFb(
const Rc<DxvkImageView>& imageView,
VkOffset3D offset,
VkExtent3D extent,
VkImageAspectFlags aspect,
VkClearValue value);
void clearImageViewCs(
const Rc<DxvkImageView>& imageView,
VkOffset3D offset,
VkExtent3D extent,
VkClearValue value);
void copyImageHw(
const Rc<DxvkImage>& dstImage,
VkImageSubresourceLayers dstSubresource,
VkOffset3D dstOffset,
const Rc<DxvkImage>& srcImage,
VkImageSubresourceLayers srcSubresource,
VkOffset3D srcOffset,
VkExtent3D extent);
void copyImageFb(
const Rc<DxvkImage>& dstImage,
VkImageSubresourceLayers dstSubresource,
VkOffset3D dstOffset,
const Rc<DxvkImage>& srcImage,
VkImageSubresourceLayers srcSubresource,
VkOffset3D srcOffset,
VkExtent3D extent);
bool copyImageClear(
const Rc<DxvkImage>& dstImage,
VkImageSubresourceLayers dstSubresource,
VkOffset3D dstOffset,
VkExtent3D dstExtent,
const Rc<DxvkImage>& srcImage,
VkImageSubresourceLayers srcSubresource);
void resolveImageHw(
const Rc<DxvkImage>& dstImage,
const Rc<DxvkImage>& srcImage,
const VkImageResolve& region);
void resolveImageDs(
const Rc<DxvkImage>& dstImage,
const Rc<DxvkImage>& srcImage,
const VkImageResolve& region,
VkResolveModeFlagBitsKHR depthMode,
VkResolveModeFlagBitsKHR stencilMode);
void resolveImageFb(
const Rc<DxvkImage>& dstImage,
const Rc<DxvkImage>& srcImage,
const VkImageResolve& region,
VkFormat format,
VkResolveModeFlagBitsKHR depthMode,
VkResolveModeFlagBitsKHR stencilMode);
void performClear(
const Rc<DxvkImageView>& imageView,
int32_t attachmentIndex,
VkImageAspectFlags discardAspects,
VkImageAspectFlags clearAspects,
VkClearValue clearValue);
void deferClear(
const Rc<DxvkImageView>& imageView,
VkImageAspectFlags clearAspects,
VkClearValue clearValue);
void deferDiscard(
const Rc<DxvkImageView>& imageView,
VkImageAspectFlags discardAspects);
void flushClears(
bool useRenderPass);
void flushSharedImages();
void startRenderPass();
void spillRenderPass(bool suspend);
void renderPassBindFramebuffer(
const Rc<DxvkFramebuffer>& framebuffer,
const DxvkRenderPassOps& ops,
uint32_t clearValueCount,
const VkClearValue* clearValues);
void renderPassUnbindFramebuffer();
void resetRenderPassOps(
const DxvkRenderTargets& renderTargets,
DxvkRenderPassOps& renderPassOps);
void startTransformFeedback();
void pauseTransformFeedback();
void unbindComputePipeline();
bool updateComputePipeline();
bool updateComputePipelineState();
void unbindGraphicsPipeline();
bool updateGraphicsPipeline();
bool updateGraphicsPipelineState();
void updateComputeShaderResources();
void updateGraphicsShaderResources();
template<VkPipelineBindPoint BindPoint>
void updateShaderResources(
const DxvkPipelineLayout* layout);
template<VkPipelineBindPoint BindPoint>
void updateShaderDescriptorSetBinding(
VkDescriptorSet set,
const DxvkPipelineLayout* layout);
void updateFramebuffer();
void applyRenderTargetLoadLayouts();
void applyRenderTargetStoreLayouts();
void transitionRenderTargetLayouts(
DxvkBarrierSet& barriers,
bool sharedOnly);
void transitionColorAttachment(
DxvkBarrierSet& barriers,
const DxvkAttachment& attachment,
VkImageLayout oldLayout);
void transitionDepthAttachment(
DxvkBarrierSet& barriers,
const DxvkAttachment& attachment,
VkImageLayout oldLayout);
void updateRenderTargetLayouts(
const Rc<DxvkFramebuffer>& newFb,
const Rc<DxvkFramebuffer>& oldFb);
void prepareImage(
DxvkBarrierSet& barriers,
const Rc<DxvkImage>& image,
const VkImageSubresourceRange& subresources,
bool flushClears = true);
bool updateIndexBufferBinding();
void updateVertexBufferBindings();
void updateTransformFeedbackBuffers();
void updateTransformFeedbackState();
void updateDynamicState();
template<VkPipelineBindPoint BindPoint>
void updatePushConstants();
bool commitComputeState();
template<bool Indexed, bool Indirect>
bool commitGraphicsState();
void commitComputeInitBarriers();
void commitComputePostBarriers();
template<bool Indexed, bool Indirect, bool DoEmit>
void commitGraphicsBarriers();
template<bool DoEmit>
DxvkAccessFlags checkGfxBufferBarrier(
const DxvkBufferSlice& slice,
VkPipelineStageFlags stages,
VkAccessFlags access);
template<bool DoEmit>
DxvkAccessFlags checkGfxImageBarrier(
const Rc<DxvkImageView>& imageView,
VkPipelineStageFlags stages,
VkAccessFlags access);
void emitMemoryBarrier(
VkDependencyFlags flags,
VkPipelineStageFlags srcStages,
VkAccessFlags srcAccess,
VkPipelineStageFlags dstStages,
VkAccessFlags dstAccess);
void initializeImage(
const Rc<DxvkImage>& image,
const VkImageSubresourceRange& subresources,
VkImageLayout dstLayout,
VkPipelineStageFlags dstStages,
VkAccessFlags dstAccess);
VkDescriptorSet allocateDescriptorSet(
VkDescriptorSetLayout layout);
void trackDrawBuffer();
DxvkGraphicsPipeline* lookupGraphicsPipeline(
const DxvkGraphicsPipelineShaders& shaders);
DxvkComputePipeline* lookupComputePipeline(
const DxvkComputePipelineShaders& shaders);
Rc<DxvkBuffer> createZeroBuffer(
VkDeviceSize size);
};
}
|