VulkanRaytracingCycles 0.0.0
Cycles Render Engine With VulkanRaytracingShaderModules. ( Experiment , in progress)
Public Member Functions | List of all members
ImmidiateCmd< Pool > Struct Template Reference

#include <CmdPoolVk.h>

Public Member Functions

 ImmidiateCmd (VkCommandPool pool)
 
 ImmidiateCmd ()
 
 ~ImmidiateCmd ()
 
bool bridgeMap (MIVSIvk &_, void *src, VkImageLayout X)
 
bool bridgeMap (MIVSIvk &_, void *src, int layer, VkImageLayout X)
 
bool bridgeMapArray (MIVSIvk &_, ktxTexture *ktxTexture, VkImageLayout X)
 
bool bridgeMap (MIVSIvk &_, void *src, std::vector< VkBufferImageCopy > &bufferCopyRegions, VkImageLayout X)
 
void free ()
 
void CopyAfterShaderRead (VkBuffer src, VkImage dst, VkBufferImageCopy bufferCopyRegion)
 
void CopyArrayAfterShaderRead (VkBuffer src, MIVSIvk &dst, std::vector< VkBufferImageCopy > bufferCopyRegion)
 
void CopyArrayAfterX (VkBuffer src, MIVSIvk &dst, std::vector< VkBufferImageCopy > _bufferCopyRegion, VkImageLayout X)
 
void CopyAfterX (VkBuffer src, MIVSIvk &dst, VkBufferImageCopy &_bufferCopyRegion, VkImageLayout X, int SubmitFlag=0)
 
void CopyAfterX (VkBuffer src, MIVSIvk &dst, std::vector< VkBufferImageCopy > &bufferCopyRegions, VkImageLayout X)
 
void MakeCopyAfterX (VkBuffer src, MIVSIvk &dst, VkBufferImageCopy &_bufferCopyRegion, VkImageLayout X)
 
void MakeCopyAfterX (VkBuffer src, MIVSIvk &dst, std::vector< VkBufferImageCopy > &bufferCopyRegions, VkImageLayout X)
 
void TransX (MIVSIvk &dst, VkImageLayout O, VkImageLayout X)
 
void BlitImageAfterX (MIVvk &dst, MIVvk &src, std::vector< VkImageBlit > BlitRegion, VkImageLayout X, VkFilter filter=VK_FILTER_NEAREST, VkImageLayout Y=VK_IMAGE_LAYOUT_UNDEFINED)
 
void CopyImageAfterX (MIVSIvk &dst, MIVSIvk &src, VkImageLayout X, VkImageLayout Y)
 

Detailed Description

template<class Pool>
struct ImmidiateCmd< Pool >

Definition at line 304 of file CmdPoolVk.h.

Inheritance diagram for ImmidiateCmd< Pool >:

Constructor & Destructor Documentation

◆ ImmidiateCmd() [1/2]

template<class Pool >
ImmidiateCmd< Pool >::ImmidiateCmd ( VkCommandPool  pool)

Definition at line 324 of file CmdPoolVk.cpp.

324 {
325 VkCommandBufferAllocateInfo cmdBufAllocateInfo = vka::plysm::commandBufferAllocateInfo(pool, VK_COMMAND_BUFFER_LEVEL_PRIMARY, 1);
326 VK_CHECK_RESULT(vkAllocateCommandBuffers($device, &cmdBufAllocateInfo, &(Pool::cmd)));
327 Pool::cmdPool = VK_NULL_HANDLE;
328};

◆ ImmidiateCmd() [2/2]

template<class Pool >
ImmidiateCmd< Pool >::ImmidiateCmd

Definition at line 331 of file CmdPoolVk.cpp.

331 {
332 Pool::alloc();
333};

◆ ~ImmidiateCmd()

template<class Pool >
ImmidiateCmd< Pool >::~ImmidiateCmd

if (cmd != VK_NULL_HANDLE) { log_bad("Memory Leak ImmidiateCommands ? %p \n", cmd); }

Definition at line 336 of file CmdPoolVk.cpp.

336 {
338 Pool::free();
339}

Member Function Documentation

◆ BlitImageAfterX()

template<class Pool >
void ImmidiateCmd< Pool >::BlitImageAfterX ( MIVvk &  dst,
MIVvk &  src,
std::vector< VkImageBlit >  BlitRegion,
VkImageLayout  X,
VkFilter  filter = VK_FILTER_NEAREST,
VkImageLayout  Y = VK_IMAGE_LAYOUT_UNDEFINED 
)

blit_region.dstSubresource.layerCount;

Definition at line 816 of file CmdPoolVk.cpp.

816 {
817 /*
818 VkImageBlit blit_region = {};
819 blit_region.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
820 blit_region.srcSubresource.baseArrayLayer = 0;
821 blit_region.srcSubresource.layerCount = 1;
822 blit_region.srcSubresource.mipLevel = 0;
823 blit_region.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
824 blit_region.dstSubresource.baseArrayLayer = 0;
825 blit_region.dstSubresource.layerCount = 1;
826 blit_region.dstSubresource.mipLevel = 0;
827 blit_region.srcOffsets[0] = { 0, 0, 0 };
828 blit_region.srcOffsets[1] = { 256, 256, 1 };
829 blit_region.dstOffsets[0] = { 0, 0, 0 };
830 blit_region.dstOffsets[1] = { 128, 128, 1 };
831 */
832
833 Pool::begin();
834
835 VkImageSubresourceRange subresourceRange = {};
836 subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
837 subresourceRange.baseMipLevel = 0;
838 subresourceRange.levelCount = 1;
839 subresourceRange.layerCount = dst.l;
840
841 vka::shelve::setImageLayout(
842 Pool::cmd,
843 dst.image,
844 dst.Info.imageLayout,
845 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
846 subresourceRange);
847
848 subresourceRange.layerCount = src.l;
849
850 vka::shelve::setImageLayout(
851 Pool::cmd,
852 src.image,
853 src.Info.imageLayout,
854 VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
855 subresourceRange);
856
857 vkCmdBlitImage(Pool::cmd, src.image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
858 dst.image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
859 (uint32_t)BlitRegion.size(), BlitRegion.data(), filter);
860
861
862 vka::shelve::setImageLayout(
863 Pool::cmd,
864 src.image,
865 VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
866 X,
867 subresourceRange);
868
869
870 subresourceRange.layerCount = dst.l;
871
872 vka::shelve::setImageLayout(
873 Pool::cmd,
874 dst.image,
875 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
876 X,
877 subresourceRange);
878
879 Pool::end();
880 Pool::submit();
881 Pool::wait();
882
883
884 log_img("setImageLayout %u --> %u \n", dst.Info.imageLayout, X);
885
886 src.Info.imageLayout = X;
887 dst.Info.imageLayout = Y;
888
889};
log_img
#define log_img(...)
Definition: ImagesVk.h:14
MIVvk::image
VkImage image
Definition: vthreepy_types.h:323
MIVvk::l
uint32_t l
Definition: vthreepy_types.h:321
MIVvk::Info
VkDescriptorImageInfo Info
Definition: vthreepy_types.h:325

◆ bridgeMap() [1/3]

template<class Pool >
bool ImmidiateCmd< Pool >::bridgeMap ( MIVSIvk &  _,
void *  src,
int  layer,
VkImageLayout  X 
)

Definition at line 385 of file CmdPoolVk.cpp.

385 {
386
387 Pool::allocStaging(_);
388
389 char* dst;
390
391 VK_CHECK_RESULT(vkMapMemory($device, Pool::staging.memory, 0, Pool::staging.allocInfo.allocationSize, 0, (void**)&dst));
392 memcpy(dst, src, _.size);
393 vkUnmapMemory($device, Pool::staging.memory);
394
395
396 VkBufferImageCopy Region = {};
397 Region.imageSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
398 Region.imageSubresource.mipLevel = 0;
399 Region.imageSubresource.layerCount = 1;
400 Region.imageSubresource.baseArrayLayer = layer;
401 Region.imageExtent.width = _.w;
402 Region.imageExtent.height = _.h;
403 Region.imageExtent.depth = 1;
404 CopyAfterX(Pool::staging.buffer, _, { Region }, X);
405
406 return true;
407
408};
ImmidiateCmd::CopyAfterX
void CopyAfterX(VkBuffer src, MIVSIvk &dst, VkBufferImageCopy &_bufferCopyRegion, VkImageLayout X, int SubmitFlag=0)
Definition: CmdPoolVk.cpp:598
MIVSIvk::size
size_t size
Definition: vthreepy_types.h:222
MIVSIvk::h
uint32_t h
Definition: vthreepy_types.h:223
MIVSIvk::w
uint32_t w
Definition: vthreepy_types.h:223

◆ bridgeMap() [2/3]

template<class Pool >
bool ImmidiateCmd< Pool >::bridgeMap ( MIVSIvk &  _,
void *  src,
std::vector< VkBufferImageCopy > &  bufferCopyRegions,
VkImageLayout  X 
)

Definition at line 448 of file CmdPoolVk.cpp.

448 {
449
450 Pool::allocStaging(_);
451
452 char* dst;
453
454 VK_CHECK_RESULT(vkMapMemory($device, Pool::staging.memory, 0, Pool::staging.allocInfo.allocationSize, 0, (void**)&dst));
455 memcpy(dst, src, _.size);
456 vkUnmapMemory($device, Pool::staging.memory);
457
458 CopyAfterX(Pool::staging.buffer, _, bufferCopyRegions, X);
459
460 return true;
461
462};

◆ bridgeMap() [3/3]

template<class Pool >
bool ImmidiateCmd< Pool >::bridgeMap ( MIVSIvk &  _,
void *  src,
VkImageLayout  X 
)

Definition at line 352 of file CmdPoolVk.cpp.

352 {
353
354 Pool::allocStaging(_);
355
356 char* dst;
357
358 VK_CHECK_RESULT(vkMapMemory($device, Pool::staging.memory, 0, Pool::staging.allocInfo.allocationSize, 0, (void**)&dst));
359 memcpy(dst, src, _.size);
360 vkUnmapMemory($device, Pool::staging.memory);
361
362
363 VkBufferImageCopy Region = {};
364 Region.imageSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
365 Region.imageSubresource.mipLevel = 0;
366 Region.imageSubresource.layerCount = 1;
367 Region.imageExtent.width = _.w;
368 Region.imageExtent.height = _.h;
369 Region.imageExtent.depth = 1;
370
371 std::vector<VkBufferImageCopy> bufferCopyRegions;
372 for (int i = 0; i < int(_.l); i++) {
373 Region.imageSubresource.baseArrayLayer = i;
374 if (i > 0)Region.imageExtent.width = 0;
375 bufferCopyRegions.push_back(Region);
376 }
377
378 CopyArrayAfterX(Pool::staging.buffer, _, std::move(bufferCopyRegions), X);
379
380
381 return true;
382
383};
ImmidiateCmd::CopyArrayAfterX
void CopyArrayAfterX(VkBuffer src, MIVSIvk &dst, std::vector< VkBufferImageCopy > _bufferCopyRegion, VkImageLayout X)
Definition: CmdPoolVk.cpp:543
MIVSIvk::l
uint32_t l
Definition: vthreepy_types.h:223

◆ bridgeMapArray()

template<class Pool >
bool ImmidiateCmd< Pool >::bridgeMapArray ( MIVSIvk &  _,
ktxTexture *  ktxTexture,
VkImageLayout  X 
)

Definition at line 410 of file CmdPoolVk.cpp.

410 {
411
412 Pool::allocStaging(_);
413
414 uint8_t* data;
415 ktx_uint8_t* ktxTextureData = ktxTexture_GetData(ktxTexture);
416 VK_CHECK_RESULT(vkMapMemory($device, Pool::staging.memory, 0, Pool::staging.memReqs.size, 0, (void**)&data));
417 memcpy(data, ktxTextureData, _.size);
418 vkUnmapMemory($device, Pool::staging.memory);
419
420
421 std::vector<VkBufferImageCopy> bufferCopyRegions;
422 for (uint32_t layer = 0; layer < _.l; layer++)
423 {
424 ktx_size_t offset;
425 KTX_error_code ret = ktxTexture_GetImageOffset(ktxTexture, 0, layer, 0, &offset);
426 assert(ret == KTX_SUCCESS);
427
428 VkBufferImageCopy bufferCopyRegion = {};
429 bufferCopyRegion.imageSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
430 bufferCopyRegion.imageSubresource.mipLevel = 0;
431 bufferCopyRegion.imageSubresource.baseArrayLayer = layer;
432 bufferCopyRegion.imageSubresource.layerCount = 1;
433 bufferCopyRegion.imageExtent.width = ktxTexture->baseWidth;
434 bufferCopyRegion.imageExtent.height = ktxTexture->baseHeight;
435 bufferCopyRegion.imageExtent.depth = 1;
436 bufferCopyRegion.bufferOffset = offset;
437 bufferCopyRegions.push_back(bufferCopyRegion);
438
439 }
440 _.Info.imageLayout = VK_IMAGE_LAYOUT_UNDEFINED;
441
442 CopyArrayAfterX(Pool::staging.buffer, _, std::move(bufferCopyRegions), X);
443
444 return true;
445}
MIVSIvk::Info
VkDescriptorImageInfo Info
Definition: vthreepy_types.h:229

◆ CopyAfterShaderRead()

template<class Pool >
void ImmidiateCmd< Pool >::CopyAfterShaderRead ( VkBuffer  src,
VkImage  dst,
VkBufferImageCopy  bufferCopyRegion 
)

Definition at line 470 of file CmdPoolVk.cpp.

470 {
471
472 Pool::begin();
473
474 vka::shelve::setImageLayout(
475 Pool::cmd,
476 dst,
477 VK_IMAGE_ASPECT_COLOR_BIT,
478 VK_IMAGE_LAYOUT_UNDEFINED,
479 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
480
481 vkCmdCopyBufferToImage(
482 Pool::cmd,
483 src,
484 dst,
485 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
486 1,
487 &bufferCopyRegion
488 );
489
490 vka::shelve::setImageLayout(
491 Pool::cmd,
492 dst,
493 VK_IMAGE_ASPECT_COLOR_BIT,
494 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
495 VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL);
496
497
498 Pool::end();
499
500};

◆ CopyAfterX() [1/2]

template<class Pool >
void ImmidiateCmd< Pool >::CopyAfterX ( VkBuffer  src,
MIVSIvk &  dst,
std::vector< VkBufferImageCopy > &  bufferCopyRegions,
VkImageLayout  X 
)

Definition at line 646 of file CmdPoolVk.cpp.

646 {
647
648 VkImageSubresourceRange subresourceRange = {};
649 subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
650 subresourceRange.baseMipLevel = 0;
651 subresourceRange.levelCount = dst.mipLevel;
652 subresourceRange.layerCount = dst.l;
653
654 Pool::begin();
655
656 vka::shelve::setImageLayout(
657 Pool::cmd,
658 dst.image,
659 dst.Info.imageLayout,
660 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
661 subresourceRange);
662
663 vkCmdCopyBufferToImage(
664 Pool::cmd,
665 src,
666 dst.image,
667 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
668 static_cast<uint32_t>(bufferCopyRegions.size()),
669 bufferCopyRegions.data()
670 );
671
672
673 vka::shelve::setImageLayout(
674 Pool::cmd,
675 dst.image,
676 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
677 X,
678 subresourceRange);
679
680 Pool::end();
681 Pool::submit();
682 Pool::wait();
683
684
685 log_img("setImageLayout %u --> %u \n", dst.Info.imageLayout, X);
686
687
688 dst.Info.imageLayout = X;
689
690};
MIVSIvk::mipLevel
uint32_t mipLevel
Definition: vthreepy_types.h:223
MIVSIvk::image
VkImage image
Definition: vthreepy_types.h:226

◆ CopyAfterX() [2/2]

template<class Pool >
void ImmidiateCmd< Pool >::CopyAfterX ( VkBuffer  src,
MIVSIvk &  dst,
VkBufferImageCopy &  _bufferCopyRegion,
VkImageLayout  X,
int  SubmitFlag = 0 
)

Definition at line 598 of file CmdPoolVk.cpp.

598 {
599
600
601 VkImageSubresourceRange subresourceRange = {};
602 subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
603 subresourceRange.baseMipLevel = 0;
604 subresourceRange.levelCount = 1;
605 subresourceRange.layerCount = 1;
606 subresourceRange.baseArrayLayer = _bufferCopyRegion.imageSubresource.baseArrayLayer;
607
608 Pool::begin();
609
610 vka::shelve::setImageLayout(
611 Pool::cmd,
612 dst.image,
613 dst.Info.imageLayout,
614 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
615 subresourceRange);
616
617 vkCmdCopyBufferToImage(
618 Pool::cmd,
619 src,
620 dst.image,
621 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
622 1,
623 &_bufferCopyRegion
624 );
625
626
627 vka::shelve::setImageLayout(
628 Pool::cmd,
629 dst.image,
630 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
631 X,
632 subresourceRange);
633
634 Pool::end();
635 Pool::submit(submitFlag);
636 Pool::wait();
637
638
639 log_img("setImageLayout %u --> %u \n", dst.Info.imageLayout, X);
640
641
642 dst.Info.imageLayout = X;
643
644};

◆ CopyArrayAfterShaderRead()

template<class Pool >
void ImmidiateCmd< Pool >::CopyArrayAfterShaderRead ( VkBuffer  src,
MIVSIvk &  dst,
std::vector< VkBufferImageCopy >  bufferCopyRegion 
)

Definition at line 502 of file CmdPoolVk.cpp.

502 {
503
504
505
506
507 Pool::begin();
508
509 VkImageSubresourceRange subresourceRange = {};
510 subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
511 subresourceRange.baseMipLevel = 0;
512 subresourceRange.levelCount = 1;
513 subresourceRange.layerCount = uint32_t(bufferCopyRegion.size());
514
515 vka::shelve::setImageLayout(
516 Pool::cmd,
517 dst.image,
518 dst.Info.imageLayout,
519 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
520 subresourceRange);
521
522 vkCmdCopyBufferToImage(
523 Pool::cmd,
524 src,
525 dst.image,
526 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
527 bufferCopyRegion.size(),
528 bufferCopyRegion.data()
529 );
530
531
532 vka::shelve::setImageLayout(
533 Pool::cmd,
534 dst.image,
535 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
536 VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
537 subresourceRange);
538
539 Pool::end();
540 dst.Info.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
541};

◆ CopyArrayAfterX()

template<class Pool >
void ImmidiateCmd< Pool >::CopyArrayAfterX ( VkBuffer  src,
MIVSIvk &  dst,
std::vector< VkBufferImageCopy >  _bufferCopyRegion,
VkImageLayout  X 
)

Definition at line 543 of file CmdPoolVk.cpp.

543 {
544
545
546 std::vector<VkBufferImageCopy> bufferCopyRegion;
547 uint32_t base = 0;
548 for (auto& region : _bufferCopyRegion) {
549 if (base > region.imageSubresource.baseArrayLayer) base = region.imageSubresource.baseArrayLayer;
550 if (region.imageExtent.width != 0)bufferCopyRegion.push_back(region);
551 };
552
553 VkImageSubresourceRange subresourceRange = {};
554 subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
555 subresourceRange.baseMipLevel = 0;
556 subresourceRange.levelCount = 1;
557 subresourceRange.layerCount = uint32_t(_bufferCopyRegion.size());
558 subresourceRange.baseArrayLayer = base;
559
560 Pool::begin();
561
562 vka::shelve::setImageLayout(
563 Pool::cmd,
564 dst.image,
565 dst.Info.imageLayout,
566 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
567 subresourceRange);
568
569 vkCmdCopyBufferToImage(
570 Pool::cmd,
571 src,
572 dst.image,
573 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
574 bufferCopyRegion.size(),
575 bufferCopyRegion.data()
576 );
577
578
579 vka::shelve::setImageLayout(
580 Pool::cmd,
581 dst.image,
582 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
583 X,
584 subresourceRange);
585
586 Pool::end();
587 Pool::submit();
588 Pool::wait();
589
590
591 log_img("setImageLayout %u --> %u \n", dst.Info.imageLayout, X);
592
593
594 dst.Info.imageLayout = X;
595
596};

◆ CopyImageAfterX()

template<class Pool >
void ImmidiateCmd< Pool >::CopyImageAfterX ( MIVSIvk &  dst,
MIVSIvk &  src,
VkImageLayout  X,
VkImageLayout  Y 
)

blit_region.dstSubresource.layerCount;

Definition at line 892 of file CmdPoolVk.cpp.

893{
894
895 VkImageCopy imageCopyRegion{};
896 imageCopyRegion.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
897 imageCopyRegion.srcSubresource.layerCount = dst.l;
898 imageCopyRegion.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
899 imageCopyRegion.dstSubresource.layerCount = dst.l;
900 imageCopyRegion.extent.width = dst.w;
901 imageCopyRegion.extent.height = dst.h;
902 imageCopyRegion.extent.depth = 1;
903
904 Pool::begin();
905
906 VkImageSubresourceRange subresourceRange = {};
907 subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
908 subresourceRange.baseMipLevel = 0;
909 subresourceRange.levelCount = 1;
910 subresourceRange.layerCount = dst.l;
911
912 vka::shelve::setImageLayout(
913 Pool::cmd,
914 dst.image,
915 dst.Info.imageLayout,
916 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
917 subresourceRange);
918
919 vka::shelve::setImageLayout(
920 Pool::cmd,
921 src.image,
922 src.Info.imageLayout,
923 VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
924 subresourceRange);
925
926 vkCmdCopyImage(
927 Pool::cmd,
928 src.image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
929 dst.image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
930 1,
931 &imageCopyRegion);
932
933
934 vka::shelve::setImageLayout(
935 Pool::cmd,
936 src.image,
937 VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
938 X,
939 subresourceRange);
940
941 vka::shelve::setImageLayout(
942 Pool::cmd,
943 dst.image,
944 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
945 Y,
946 subresourceRange);
947
948 Pool::end();
949 Pool::submit();
950 Pool::wait();
951
952 log_img("setImageLayout %u --> %u \n", dst.Info.imageLayout, X);
953
954 src.Info.imageLayout = X;
955 dst.Info.imageLayout = Y;
956
957}

◆ free()

template<class Pool >
void ImmidiateCmd< Pool >::free

Definition at line 465 of file CmdPoolVk.cpp.

465 {
466 Pool::free();
467}

◆ MakeCopyAfterX() [1/2]

template<class Pool >
void ImmidiateCmd< Pool >::MakeCopyAfterX ( VkBuffer  src,
MIVSIvk &  dst,
std::vector< VkBufferImageCopy > &  bufferCopyRegions,
VkImageLayout  X 
)

Definition at line 769 of file CmdPoolVk.cpp.

769 {
770
771 VkImageSubresourceRange subresourceRange = {};
772 subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
773 subresourceRange.baseMipLevel = 0;
774 subresourceRange.levelCount = dst.mipLevel;
775 subresourceRange.layerCount = dst.l;
776
777 Pool::begin();
778
779 vka::shelve::setImageLayout(
780 Pool::cmd,
781 dst.image,
782 dst.Info.imageLayout,
783 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
784 subresourceRange);
785
786 vkCmdCopyBufferToImage(
787 Pool::cmd,
788 src,
789 dst.image,
790 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
791 static_cast<uint32_t>(bufferCopyRegions.size()),
792 bufferCopyRegions.data()
793 );
794
795
796 vka::shelve::setImageLayout(
797 Pool::cmd,
798 dst.image,
799 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
800 X,
801 subresourceRange);
802
803 Pool::end();
804
805
806
807 log_img("setImageLayout %u --> %u \n", dst.Info.imageLayout, X);
808
809
810 dst.Info.imageLayout = X;
811
812};

◆ MakeCopyAfterX() [2/2]

template<class Pool >
void ImmidiateCmd< Pool >::MakeCopyAfterX ( VkBuffer  src,
MIVSIvk &  dst,
VkBufferImageCopy &  _bufferCopyRegion,
VkImageLayout  X 
)

Definition at line 723 of file CmdPoolVk.cpp.

723 {
724
725
726 VkImageSubresourceRange subresourceRange = {};
727 subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
728 subresourceRange.baseMipLevel = 0;
729 subresourceRange.levelCount = 1;
730 subresourceRange.layerCount = 1;
731 subresourceRange.baseArrayLayer = _bufferCopyRegion.imageSubresource.baseArrayLayer;
732
733 Pool::begin();
734
735 vka::shelve::setImageLayout(
736 Pool::cmd,
737 dst.image,
738 dst.Info.imageLayout,
739 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
740 subresourceRange);
741
742 vkCmdCopyBufferToImage(
743 Pool::cmd,
744 src,
745 dst.image,
746 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
747 1,
748 &_bufferCopyRegion
749 );
750
751
752 vka::shelve::setImageLayout(
753 Pool::cmd,
754 dst.image,
755 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
756 X,
757 subresourceRange);
758
759 Pool::end();
760
761
762 log_img("setImageLayout %u --> %u \n", dst.Info.imageLayout, X);
763
764
765 dst.Info.imageLayout = X;
766
767};

◆ TransX()

template<class Pool >
void ImmidiateCmd< Pool >::TransX ( MIVSIvk &  dst,
VkImageLayout  O,
VkImageLayout  X 
)

Definition at line 693 of file CmdPoolVk.cpp.

693 {
694
695 VkImageSubresourceRange subresourceRange = {};
696 subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
697 subresourceRange.baseMipLevel = 0;
698 subresourceRange.levelCount = dst.mipLevel;
699 subresourceRange.layerCount = dst.l;
700
701 Pool::begin();
702
703 vka::shelve::setImageLayout(
704 Pool::cmd,
705 dst.image,
706 O,
707 X,
708 subresourceRange);
709
710 Pool::end();
711 Pool::submit();
712 Pool::wait();
713
714
715 log_img("setImageLayout %u --> %u \n", dst.Info.imageLayout, X);
716
717
718 dst.Info.imageLayout = X;
719
720};
The documentation for this struct was generated from the following files: