VulkanRaytracingCycles 0.0.0
Cycles Render Engine With VulkanRaytracingShaderModules. ( Experiment , in progress)
Public Types | Public Member Functions | Public Attributes | List of all members
ObjectsVk Struct Reference

#include <ObjectVk.h>

Public Types

typedef tbb::concurrent_unordered_map< std::string, int, std::hash< std::string >, std::equal_to< std::string >, front::tbbTAllocator > tb_umapII
 typedef tbb::concurrent_unordered_map<std::string, int, tbb::tbb_hash<std::string>, std::equal_to<std::string>, front::tbbTAllocator> tb_umapII; More...
 

Public Member Functions

 ObjectsVk ()
 
 ~ObjectsVk ()
 
void destroy ()
 
template<class T , class Mem >
bool $AllocMemory$ (T &cmder, Mem &mach)
 
template<class Geom >
bool $createDeviceBufferSeparate$ (Geom &bach, VkDeviceMemory memory, VkBufferUsageFlags usage=VK_BUFFER_USAGE_VERTEX_BUFFER_BIT)
 
template<class Geom >
bool createBufferView (Geom &bach, VkDeviceSize offset=0, VkBufferUsageFlags usage=VK_BUFFER_USAGE_VERTEX_BUFFER_BIT)
 
template<class T >
bool $createBuffer$ (T &bach, VkMemoryPropertyFlags memTy)
 
template<class T , class B >
bool $createBuffer$ (T &cmder, StoBache &bach, std::vector< B > &src, VkMemoryPropertyFlags memTy, VkBufferUsageFlags usage=VK_BUFFER_USAGE_STORAGE_BUFFER_BIT)
 
template<class T , class AS >
bool $createBuffer$ (T &cmder, StoBache &bach, AS &as, VkMemoryPropertyFlags memTy)
 
template<class T , class O >
bool $createBuffer$ (T &cmder, std::vector< O * > &objs, MBvk &input, MBvk &index)
 
template<class T , class Geom >
bool $createBuffer$ (T &cmder, Geom *&geometry, bool _createInfo)
 
template<class T , class Geom >
bool $createBufferInstanced$ (T &cmder, Geom *&geometry, bool _createInfo, VkBufferUsageFlags usage=VK_BUFFER_USAGE_STORAGE_BUFFER_BIT|VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT|VK_BUFFER_USAGE_TRANSFER_DST_BIT, VkMemoryPropertyFlags mem=VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT)
 
template<class T , class Geom >
bool $createSpriteBuffer$ (T &cmder, Geom *&geometry, bool _createInfo)
 
template<class Geom >
bool $createDeviceBuffer$ (Geom &geometry, bool _createInfo, VkBufferUsageFlags usage=VK_BUFFER_USAGE_VERTEX_BUFFER_BIT)
 
template<class T , class B >
bool $BridgeMapBuffer$ (T &cmder, B &dev, void *data, VkDeviceSize size, VkDeviceSize dstOffset=0, VkDeviceSize srcOffset=0)
 
template<class T >
bool $BridgeMapBuffer$ (T &cmder, VkDescriptorBufferInfo &dev, void *data, VkDeviceSize srcOffset=0)
 
template<typename Geom >
void $createVertexInfo$ (Geom *geometry, int type=0)
 
bool getVertexInfo (VkPipelineVertexInputStateCreateInfo *&info, arth::INPUT Ity)
 
template<class Geom >
bool getMemory (Mvk &mem, Geom &geometry)
 
template<class Geom >
bool getBuffer (MBvk &mem, Geom *geometry)
 
template<class Geom >
bool getIndex (MBvk &mem, Geom *geometry)
 
template<class Geom >
bool Delete (Geom *geometry)
 
template<class Geom >
bool DeleteMB (Geom &hach)
 
template<class Geom >
bool DeleteIBm (Geom &hach)
 
template<class Geom >
bool DeleteM (Geom &hach)
 

Public Attributes

SRWLOCK slim
 
tb_umapII mth
 
tb_umapII inth
 

Detailed Description

Definition at line 311 of file ObjectVk.h.

Member Typedef Documentation

◆ tb_umapII

typedef tbb::concurrent_unordered_map<std::string, int, std::hash<std::string>, std::equal_to<std::string>, front::tbbTAllocator> ObjectsVk::tb_umapII

typedef tbb::concurrent_unordered_map<std::string, int, tbb::tbb_hash<std::string>, std::equal_to<std::string>, front::tbbTAllocator> tb_umapII;

Definition at line 315 of file ObjectVk.h.

Constructor & Destructor Documentation

◆ ObjectsVk()

ObjectsVk::ObjectsVk ( )

auto IndexType = []<typename T>(const T & n) { return n.type; }; static std::unordered_map< arth::INPUT, vkPVISci, decltype(IndexType)> VInfo(0, IndexType);

Definition at line 39 of file ObjectVk.cpp.

39 {
40 InitializeSRWLock(&slim);
41
42
43};
ObjectsVk::slim
SRWLOCK slim
Definition: ObjectVk.h:313

◆ ~ObjectsVk()

ObjectsVk::~ObjectsVk ( )

Definition at line 44 of file ObjectVk.cpp.

44{ destroy(); };
ObjectsVk::destroy
void destroy()
Definition: ObjectVk.cpp:45

Member Function Documentation

◆ $AllocMemory$()

template<class T , class Mem >
bool ObjectsVk::$AllocMemory$ ( T &  cmder,
Mem &  mach 
)
inline

Definition at line 327 of file ObjectVk.h.

328 {
329
330 long orig = InterlockedCompareExchange(&(mach.id), INT32_MAX, -1);
331 if (orig != -1) return false;
332
333 Mvk mem;
334 {
335
336 VkMemoryRequirements memReqs = {};
337 VkMemoryAllocateInfo memAlloc = {};
338 memAlloc.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
339
340 VkBufferCreateInfo BufferInfo = {};
341 VkBuffer buffer;
342
343 BufferInfo.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
344 BufferInfo.usage = 0xff;
345 VkDeviceSize offset = 0;
346 mach.memSize = 0; memAlloc.allocationSize = 0;
347 for (auto& v : mach.sizeSet) {
348 BufferInfo.size = v;
349 VK_CHECK_RESULT(vkCreateBuffer($device, &BufferInfo, nullptr, &buffer));
350 vkGetBufferMemoryRequirements($device, buffer, &memReqs);
351 vkDestroyBuffer($device, buffer, nullptr);
352 memAlloc.allocationSize += memReqs.size;
353 mach.memSize += BufferInfo.size;
354 v = offset;
355 offset += memReqs.size;
356 };
357 mach.reqSize = memAlloc.allocationSize;
358 memAlloc.memoryTypeIndex = vka::shelve::getMemoryTypeIndex(memReqs.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
359 VK_CHECK_RESULT(vkAllocateMemory($device, &memAlloc, nullptr, &mem.memory));
360
361 };
362
363
364 Mem(Mvk, SIZE_MDev).$set$(std::move(mem), &mach.mem);
365
366 int c = (int)mth.size();
367 mth["memory" + std::to_string(c)] = (mach.mem.id);
368
369
370 return true;
371
372 };
SIZE_MDev
#define SIZE_MDev
Definition: ObjectVk.h:18
Mem
#define Mem(vk, sz)
Definition: incomplete.h:329
Mvk::memory
VkDeviceMemory memory
Definition: vthreepy_types.h:378
Mvk::size
size_t size
Definition: vthreepy_types.h:379
ObjectsVk::mth
tb_umapII mth
Definition: ObjectVk.h:317

◆ $BridgeMapBuffer$() [1/2]

template<class T , class B >
bool ObjectsVk::$BridgeMapBuffer$ ( T &  cmder,
B &  dev,
void *  data,
VkDeviceSize  size,
VkDeviceSize  dstOffset = 0,
VkDeviceSize  srcOffset = 0 
)
inline

Definition at line 933 of file ObjectVk.h.

934 {
935
936 cmder.allocStaging(size);
937 cmder.Map(data, srcOffset, size);
938 cmder.begin();
939 cmder.Copy(dev, size, srcOffset, dstOffset);
940 cmder.end();
941 cmder.submit();
942 cmder.wait();
943
944 return true;
945
946 };

◆ $BridgeMapBuffer$() [2/2]

template<class T >
bool ObjectsVk::$BridgeMapBuffer$ ( T &  cmder,
VkDescriptorBufferInfo &  dev,
void *  data,
VkDeviceSize  srcOffset = 0 
)
inline

Definition at line 949 of file ObjectVk.h.

950 {
951
952 cmder.allocStaging(dev.range);
953 cmder.Map(data, srcOffset, dev.range);
954 cmder.begin();
955 cmder.Copy(dev, dev.range, srcOffset, dev.offset);
956 cmder.end();
957 cmder.submit();
958 cmder.wait();
959
960 return true;
961
962 };

◆ $createBuffer$() [1/5]

template<class T >
bool ObjectsVk::$createBuffer$ ( T &  bach,
VkMemoryPropertyFlags  memTy 
)
inline

Definition at line 441 of file ObjectVk.h.

442 {
443
444 long orig = InterlockedCompareExchange(&(bach.id), INT32_MAX, -1);
445 if (orig != -1) return false;
446
447 MBvk asMb;
448 VkBufferCreateInfo BufferInfo = {};
449 {
450
451 VkMemoryRequirements memReqs;
452 VkMemoryAllocateInfo memAlloc = {};
453 memAlloc.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
454 BufferInfo.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
455 BufferInfo.size = bach.size;
456 BufferInfo.usage = VK_BUFFER_USAGE_RAY_TRACING_BIT_NV | VK_BUFFER_USAGE_TRANSFER_DST_BIT;
457
458
459 VK_CHECK_RESULT(vkCreateBuffer($device, &BufferInfo, nullptr, &asMb.buffer));
460 vkGetBufferMemoryRequirements($device, asMb.buffer, &memReqs);
461 memAlloc.allocationSize = memReqs.size;
462 memAlloc.memoryTypeIndex = vka::shelve::getMemoryTypeIndex(memReqs.memoryTypeBits, memTy);
463 VK_CHECK_RESULT(vkAllocateMemory($device, &memAlloc, nullptr, &asMb.memory));
464 VK_CHECK_RESULT(vkBindBufferMemory($device, asMb.buffer, asMb.memory, 0));
465
466 }
467
468 Mem(MBvk, SIZE_MB).$set$(std::move(asMb), &bach.buffer);
469 bach.info.buffer = bach.vkBuffer = asMb.buffer;
470 bach.info.range = BufferInfo.size;
471 bach.info.offset = 0;
472
473
474 int c = (int)inth.size();
475 inth["buffer" + std::to_string(c)] = (bach.buffer.id);
476
477
478 return true;
479
480 };
SIZE_MB
#define SIZE_MB
Definition: ObjectVk.h:21
MBvk::buffer
VkBuffer buffer
Definition: vthreepy_types.h:134
MBvk::memory
VkDeviceMemory memory
Definition: vthreepy_types.h:133
ObjectsVk::inth
tb_umapII inth
Definition: ObjectVk.h:318

◆ $createBuffer$() [2/5]

template<class T , class Geom >
bool ObjectsVk::$createBuffer$ ( T &  cmder,
Geom *&  geometry,
bool  _createInfo 
)
inline

Definition at line 666 of file ObjectVk.h.

667 {
668
669 long orig = InterlockedCompareExchange(&(geometry->id), INT32_MAX, -1);
670 if (orig != -1) return false;
671
672 MBvk input;
673 MBvk index;
674 VkDeviceSize size = 0;
675 {
676
677 VkMemoryRequirements memReqs;
678 VkMemoryAllocateInfo memAlloc = {};
679 memAlloc.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
680
681 VkBufferCreateInfo BufferInfo = {};
682 BufferInfo.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
683 BufferInfo.size = geometry->array.memorySize;
684 BufferInfo.usage = VK_BUFFER_USAGE_VERTEX_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT;
685
686 size = geometry->array.memorySize;
687
688 VK_CHECK_RESULT(vkCreateBuffer($device, &BufferInfo, nullptr, &input.buffer));
689 vkGetBufferMemoryRequirements($device, input.buffer, &memReqs);
690 memAlloc.allocationSize = memReqs.size;
691 memAlloc.memoryTypeIndex = vka::shelve::getMemoryTypeIndex(memReqs.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
692 VK_CHECK_RESULT(vkAllocateMemory($device, &memAlloc, nullptr, &input.memory));
693 VK_CHECK_RESULT(vkBindBufferMemory($device, input.buffer, input.memory, 0));
694
695
696 BufferInfo.size = geometry->Size.index;
697
698 size += geometry->Size.index;
699 BufferInfo.usage = VK_BUFFER_USAGE_INDEX_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT;
700 VK_CHECK_RESULT(vkCreateBuffer($device, &BufferInfo, nullptr, &index.buffer));
701 vkGetBufferMemoryRequirements($device, index.buffer, &memReqs);
702 memAlloc.allocationSize = memReqs.size;
703 memAlloc.memoryTypeIndex = vka::shelve::getMemoryTypeIndex(memReqs.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
704 VK_CHECK_RESULT(vkAllocateMemory($device, &memAlloc, nullptr, &index.memory));
705 VK_CHECK_RESULT(vkBindBufferMemory($device, index.buffer, index.memory, 0));
706
707 }
708
709 cmder.allocStaging(size);
710
711 cmder.Map(geometry->map(1), 0, geometry->array.memorySize);
712 cmder.Map(geometry->map(0), geometry->array.memorySize, geometry->Size.index);
713
714
715 cmder.begin();
716 cmder.Copy(input, geometry->array.memorySize, 0, 0);
717 cmder.Copy(index, geometry->Size.index, geometry->array.memorySize, 0);
718 cmder.end();
719 cmder.submit();
720
721
722 if (_createInfo)$createVertexInfo$(geometry);
723 index.count = geometry->updateRange.count;
724
725 cmder.wait();
726
727 Mem(MBvk,SIZE_MB).$set$(std::move(input), geometry);
728 geometry->ID.vert = geometry->id;
729 geometry->info.vert = {
730 .buffer = input.buffer,
731 .offset = 0,
732 .range = geometry->array.memorySize
733 };
734
735
736 Mem(MBvk,SIZE_MB).$set$(std::move(index), geometry);
737 geometry->ID.index = geometry->id;
738 geometry->info.index = {
739 .buffer = index.buffer,
740 .offset = 0,
741 .range = geometry->Size.index
742 };
743
744 int c = (int)inth.size();
745 inth["vertex" + std::to_string(c)] = geometry->ID.vert;
746 c = (int)inth.size();
747 inth["index" + std::to_string(c)] = geometry->ID.index;
748
749 return true;
750
751 };
MBvk::count
uint32_t count
Definition: vthreepy_types.h:137
ObjectsVk::$createVertexInfo$
void $createVertexInfo$(Geom *geometry, int type=0)
Definition: ObjectVk.h:966

◆ $createBuffer$() [3/5]

template<class T , class O >
bool ObjectsVk::$createBuffer$ ( T &  cmder,
std::vector< O * > &  objs,
MBvk &  input,
MBvk &  index 
)
inline

Definition at line 593 of file ObjectVk.h.

594 {
595
596
597
598 VkDeviceSize size = 0;
599 {
600
601 VkMemoryRequirements memReqs;
602 VkMemoryAllocateInfo memAlloc = {};
603 memAlloc.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
604
605 VkBufferCreateInfo BufferInfo = {};
606 BufferInfo.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
607 BufferInfo.size = input.count;
608 BufferInfo.usage = VK_BUFFER_USAGE_VERTEX_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT;
609
610 size = BufferInfo.size;
611
612 VK_CHECK_RESULT(vkCreateBuffer($device, &BufferInfo, nullptr, &input.buffer));
613 vkGetBufferMemoryRequirements($device, input.buffer, &memReqs);
614 memAlloc.allocationSize = memReqs.size;
615 memAlloc.memoryTypeIndex = vka::shelve::getMemoryTypeIndex(memReqs.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
616 VK_CHECK_RESULT(vkAllocateMemory($device, &memAlloc, nullptr, &input.memory));
617 VK_CHECK_RESULT(vkBindBufferMemory($device, input.buffer, input.memory, 0));
618
619
620 BufferInfo.size = index.count;
621
622 size += BufferInfo.size;
623 BufferInfo.usage = VK_BUFFER_USAGE_INDEX_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT;
624 VK_CHECK_RESULT(vkCreateBuffer($device, &BufferInfo, nullptr, &index.buffer));
625 vkGetBufferMemoryRequirements($device, index.buffer, &memReqs);
626 memAlloc.allocationSize = memReqs.size;
627 memAlloc.memoryTypeIndex = vka::shelve::getMemoryTypeIndex(memReqs.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
628 VK_CHECK_RESULT(vkAllocateMemory($device, &memAlloc, nullptr, &index.memory));
629 VK_CHECK_RESULT(vkBindBufferMemory($device, index.buffer, index.memory, 0));
630
631 }
632
633 cmder.allocStaging(size);
634 printf(" total map 1 %u 2 %u \n", input.count, index.count);
635 for (auto& obj : objs) {
636
637 auto g = OBJ_GEOM(obj);
638 auto& info = g->info.vert;
639 info.buffer = input.buffer;
640 cmder.Map(g->map(1), info.offset, g->array.memorySize);
641 printf(" Map vertex(%p) offset %zu range %zu \n ", input.buffer, info.offset, info.range);
642 auto& info2 = g->info.index;
643 info2.buffer = index.buffer;
644 cmder.Map(g->map(0), input.count + info2.offset, g->Size.index);
645 printf(" Map index(%p) offset %zu range %zu\n ", index.buffer, info2.offset, info2.range);
646
647 }
648
649
650
651
652 cmder.begin();
653 cmder.Copy(input, input.count, 0, 0);
654 cmder.Copy(index, index.count, input.count, 0);
655 cmder.end();
656 cmder.submit();
657
658 cmder.wait();
659
660
661 return true;
662
663 };
OBJ_GEOM
#define OBJ_GEOM(obj)
Definition: incomplete.h:336

◆ $createBuffer$() [4/5]

template<class T , class AS >
bool ObjectsVk::$createBuffer$ ( T &  cmder,
StoBache &  bach,
AS &  as,
VkMemoryPropertyFlags  memTy 
)
inline

Definition at line 538 of file ObjectVk.h.

539 {
540
541 long orig = InterlockedCompareExchange(&(bach.id), INT32_MAX, -1);
542 if (orig != -1) return false;
543
544 MBvk asMb;
545 VkBufferCreateInfo BufferInfo = {};
546 {
547
548 VkMemoryRequirements memReqs;
549 VkMemoryAllocateInfo memAlloc = {};
550 memAlloc.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
551
552
553 BufferInfo.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
554 BufferInfo.size = sizeof(AS);
555 BufferInfo.usage = VK_BUFFER_USAGE_RAY_TRACING_BIT_NV | VK_BUFFER_USAGE_TRANSFER_DST_BIT;
556
557
558 VK_CHECK_RESULT(vkCreateBuffer($device, &BufferInfo, nullptr, &asMb.buffer));
559 vkGetBufferMemoryRequirements($device, asMb.buffer, &memReqs);
560 memAlloc.allocationSize = memReqs.size;
561 memAlloc.memoryTypeIndex = vka::shelve::getMemoryTypeIndex(memReqs.memoryTypeBits,memTy);
562 VK_CHECK_RESULT(vkAllocateMemory($device, &memAlloc, nullptr, &asMb.memory));
563 VK_CHECK_RESULT(vkBindBufferMemory($device, asMb.buffer, asMb.memory, 0));
564
565 }
566
567 cmder.allocStaging(BufferInfo.size);
568
569 cmder.Map(&as, 0, BufferInfo.size);
570
571
572
573 cmder.begin();
574 cmder.Copy(asMb,BufferInfo.size, 0, 0);
575 cmder.end();
576 cmder.submit();
577
578 cmder.wait();
579
580 Mem(MBvk, SIZE_MB).$set$(std::move(asMb), &bach.buffer);
581 bach.info.buffer = bach.vkBuffer = asMb.buffer;
582 bach.info.range = BufferInfo.size;
583 bach.info.offset = 0;
584 int c = (int)inth.size();
585 inth["buffer" + std::to_string(c)] = (bach.buffer.id);
586
587
588 return true;
589
590 };
StoBache::vkBuffer
VkBuffer vkBuffer
Definition: incomplete.h:217
StoBache::info
VkDescriptorBufferInfo info
Definition: incomplete.h:218
StoBache::buffer
Hache buffer
Definition: incomplete.h:209
StoBache::id
long id
Definition: incomplete.h:208

◆ $createBuffer$() [5/5]

template<class T , class B >
bool ObjectsVk::$createBuffer$ ( T &  cmder,
StoBache &  bach,
std::vector< B > &  src,
VkMemoryPropertyFlags  memTy,
VkBufferUsageFlags  usage = VK_BUFFER_USAGE_STORAGE_BUFFER_BIT 
)
inline

Definition at line 482 of file ObjectVk.h.

483 {
484
485 long orig = InterlockedCompareExchange(&(bach.id), INT32_MAX, -1);
486 if (orig != -1) return false;
487
488 MBvk asMb;
489 VkBufferCreateInfo BufferInfo = {};
490 {
491
492 VkMemoryRequirements memReqs;
493 VkMemoryAllocateInfo memAlloc = {};
494 memAlloc.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
495
496
497 BufferInfo.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
498 BufferInfo.size = sizeof(B)* src.size();
499 BufferInfo.usage = usage | VK_BUFFER_USAGE_TRANSFER_DST_BIT;
500
501
502 VK_CHECK_RESULT(vkCreateBuffer($device, &BufferInfo, nullptr, &asMb.buffer));
503 vkGetBufferMemoryRequirements($device, asMb.buffer, &memReqs);
504 memAlloc.allocationSize = memReqs.size;
505 memAlloc.memoryTypeIndex = vka::shelve::getMemoryTypeIndex(memReqs.memoryTypeBits, memTy);
506 VK_CHECK_RESULT(vkAllocateMemory($device, &memAlloc, nullptr, &asMb.memory));
507 VK_CHECK_RESULT(vkBindBufferMemory($device, asMb.buffer, asMb.memory, 0));
508
509 }
510
511 cmder.allocStaging(BufferInfo.size);
512
513 cmder.Map(src.data(), 0, BufferInfo.size);
514
515
516
517 cmder.begin();
518 cmder.Copy(asMb, BufferInfo.size, 0, 0);
519 cmder.end();
520 cmder.submit();
521
522 cmder.wait();
523
524 Mem(MBvk, SIZE_MB).$set$(std::move(asMb), &bach.buffer);
525 bach.info.buffer = bach.vkBuffer = asMb.buffer;
526 bach.info.range = BufferInfo.size;
527 bach.info.offset = 0;
528
529 int c = (int)inth.size();
530 inth["buffer" + std::to_string(c)] = (bach.buffer.id);
531
532
533 return true;
534
535 };

◆ $createBufferInstanced$()

template<class T , class Geom >
bool ObjectsVk::$createBufferInstanced$ ( T &  cmder,
Geom *&  geometry,
bool  _createInfo,
VkBufferUsageFlags  usage = VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT,
VkMemoryPropertyFlags  mem = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT 
)
inline

Definition at line 755 of file ObjectVk.h.

756 {
757
758 assert(geometry->instance != nullptr);
759
760 if (geometry->attributes != nullptr) $createBuffer$(cmder, geometry->attributes->buffer, false);
761
762 long orig = InterlockedCompareExchange(&(geometry->instance->buffer->id), INT32_MAX, -1);
763 if (orig != -1) return false;
764
765 MBvk insta;
766
767 auto buf = geometry->instance->buffer;
768 VkDeviceSize size = buf->array.memorySize;
769 {
770
771 VkMemoryRequirements memReqs;
772 VkMemoryAllocateInfo memAlloc = {};
773 memAlloc.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
774
775 VkBufferCreateInfo BufferInfo = {};
776 BufferInfo.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
777 BufferInfo.size = size;
778 BufferInfo.usage = VK_BUFFER_USAGE_VERTEX_BUFFER_BIT | usage;
779
780 VK_CHECK_RESULT(vkCreateBuffer($device, &BufferInfo, nullptr, &insta.buffer));
781 vkGetBufferMemoryRequirements($device, insta.buffer, &memReqs);
782 memAlloc.allocationSize = memReqs.size;
783 memAlloc.memoryTypeIndex = vka::shelve::getMemoryTypeIndex(memReqs.memoryTypeBits, mem);
784 VK_CHECK_RESULT(vkAllocateMemory($device, &memAlloc, nullptr, &insta.memory));
785 VK_CHECK_RESULT(vkBindBufferMemory($device, insta.buffer, insta.memory, 0));
786
787 }
788
789 cmder.allocStaging(size);
790 cmder.Map(buf->map(1), 0, size);
791 cmder.begin();
792 cmder.Copy(insta, size, 0, 0);
793 cmder.end();
794 cmder.submit();
795
796 $VInfo.$setInstanced$(geometry);
797
798
799 cmder.wait();
800
801 geometry->instance->buffer->info.attr.buffer = insta.buffer;
802 geometry->instance->buffer->info.attr.range = size;
803 geometry->instance->buffer->info.attr.offset = 0;
804
805 Mem(MBvk,SIZE_MB).$set$(std::move(insta), buf);
806 int c = (int)inth.size();
807 inth["instance" + std::to_string(c)] = buf->id;
808
809
810
811 return true;
812
813 };
ObjectsVk::$createBuffer$
bool $createBuffer$(T &bach, VkMemoryPropertyFlags memTy)
Definition: ObjectVk.h:441

◆ $createDeviceBuffer$()

template<class Geom >
bool ObjectsVk::$createDeviceBuffer$ ( Geom &  geometry,
bool  _createInfo,
VkBufferUsageFlags  usage = VK_BUFFER_USAGE_VERTEX_BUFFER_BIT 
)
inline

Definition at line 889 of file ObjectVk.h.

890 {
891
892 long orig = InterlockedCompareExchange(&(geometry.id), INT32_MAX, -1);
893 if (orig != -1) return false;
894
895 MBvk input;
896 VkDeviceSize size = geometry.array.memorySize;
897 {
898
899 VkMemoryRequirements memReqs;
900 VkMemoryAllocateInfo memAlloc = {};
901 memAlloc.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
902
903 VkBufferCreateInfo BufferInfo = {};
904 BufferInfo.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
905 BufferInfo.size = size;
906 BufferInfo.usage = usage | VK_BUFFER_USAGE_TRANSFER_DST_BIT;
907
908
909
910 VK_CHECK_RESULT(vkCreateBuffer($device, &BufferInfo, nullptr, &input.buffer));
911 vkGetBufferMemoryRequirements($device, input.buffer, &memReqs);
912 memAlloc.allocationSize = memReqs.size;
913 memAlloc.memoryTypeIndex = vka::shelve::getMemoryTypeIndex(memReqs.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
914 VK_CHECK_RESULT(vkAllocateMemory($device, &memAlloc, nullptr, &input.memory));
915 VK_CHECK_RESULT(vkBindBufferMemory($device, input.buffer, input.memory, 0));
916
917 if (_createInfo)$createVertexInfo$(&geometry);
918
919 };
920
921
922
923 Mem(MBvk,SIZE_MB).$set$(std::move(input), &geometry);
924 geometry.ID.vert = geometry.id;
925 int c = (int)inth.size();
926 inth["mbvk" + std::to_string(c)] = (geometry.ID.vert);
927
928
929 return true;
930 };

◆ $createDeviceBufferSeparate$()

template<class Geom >
bool ObjectsVk::$createDeviceBufferSeparate$ ( Geom &  bach,
VkDeviceMemory  memory,
VkBufferUsageFlags  usage = VK_BUFFER_USAGE_VERTEX_BUFFER_BIT 
)
inline

Definition at line 375 of file ObjectVk.h.

376 {
377
378 long orig = InterlockedCompareExchange(&(bach.id), INT32_MAX, -1);
379 if (orig != -1) return false;
380
381 IBmvk input;
382 {
383
384 VkMemoryRequirements memReqs;
385 VkMemoryAllocateInfo memAlloc = {};
386 memAlloc.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
387
388 VkBufferCreateInfo BufferInfo = {};
389 BufferInfo.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
390 BufferInfo.size = bach.size;
391 BufferInfo.usage = usage | VK_BUFFER_USAGE_TRANSFER_DST_BIT;
392
393 VK_CHECK_RESULT(vkCreateBuffer($device, &BufferInfo, nullptr, &input.buffer));
394 vkGetBufferMemoryRequirements($device, input.buffer, &memReqs);
395 bach.reqSize = memAlloc.allocationSize = memReqs.size;
396 memAlloc.memoryTypeIndex = vka::shelve::getMemoryTypeIndex(memReqs.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
397
398 VK_CHECK_RESULT(vkBindBufferMemory($device, input.buffer, memory, bach.offset));
399
400 };
401
402
403
404 bach.vkBuffer = input.buffer;
405 input.info.buffer = input.buffer;
406 input.info.offset = 0;
407 input.info.range = bach.size;
408 bach.info = input.info;
409 Mem(IBmvk, SIZE_IBmDev).$set$(std::move(input), &bach.buffer);
410
411 int c = (int)mth.size();
412 mth["memory" + std::to_string(c)] = (bach.buffer.id);
413
414
415
416 return true;
417 };
SIZE_IBmDev
#define SIZE_IBmDev
Definition: ObjectVk.h:25
IBmvk::info
VkDescriptorBufferInfo info
Definition: vthreepy_types.h:394
IBmvk::buffer
VkBuffer buffer
Definition: vthreepy_types.h:395
IBmvk::size
VkDeviceSize size
Definition: vthreepy_types.h:397

◆ $createSpriteBuffer$()

template<class T , class Geom >
bool ObjectsVk::$createSpriteBuffer$ ( T &  cmder,
Geom *&  geometry,
bool  _createInfo 
)
inline

memcpy(data, f, 16 * 4);

Definition at line 817 of file ObjectVk.h.

818 {
819
820 long orig = InterlockedCompareExchange(&(geometry->id), INT32_MAX, -1);
821 if (orig != -1) return false;
822 MBvk input;
823 log_obj("create Sprite Buffer %d %x \n", geometry->id, input.buffer);
824
825
826 VkDeviceSize size = 16*4;
827 {
828
829 VkMemoryRequirements memReqs;
830 VkMemoryAllocateInfo memAlloc = {};
831 memAlloc.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
832
833 VkBufferCreateInfo BufferInfo = {};
834 BufferInfo.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
835 BufferInfo.size = size;
836 BufferInfo.usage = VK_BUFFER_USAGE_VERTEX_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT;
837
838
839 VK_CHECK_RESULT(vkCreateBuffer($device, &BufferInfo, nullptr, &input.buffer));
840 vkGetBufferMemoryRequirements($device, input.buffer, &memReqs);
841 memAlloc.allocationSize = memReqs.size;
842 memAlloc.memoryTypeIndex = vka::shelve::getMemoryTypeIndex(memReqs.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
843 VK_CHECK_RESULT(vkAllocateMemory($device, &memAlloc, nullptr, &input.memory));
844 VK_CHECK_RESULT(vkBindBufferMemory($device, input.buffer, input.memory, 0));
845
846 }
847
848
849 static float invf[16] = { -1.f, -1.f, 0.f, 1.f,
850 1.f, -1.f , 1.f, 1.f,
851 -1.f, 1.f , 0.f, 0.f,
852 1.f, 1.f , 1.f, 0.f
853 };
854 static float f[16] = { -1.f, -1.f, 0.f, 0.f,
855 1.f, -1.f , 1.f, 0.f,
856 -1.f, 1.f , 0.f, 1.f,
857 1.f, 1.f , 1.f, 1.f
858 };
859
861 log_obj("create Sprite Buffer %d %x updateRange %d \n", geometry->id, input.buffer, geometry->updateRange.count);
862
863 cmder.allocStaging(size);
864
865 cmder.Map( (void*)f, 0, size);
866 cmder.begin();
867 cmder.Copy(input, size, 0, 0);
868 cmder.end();
869 cmder.submit();
870
871
872 if (_createInfo)$createVertexInfo$(geometry,1);
873 input.count = geometry->updateRange.count;
874
875 cmder.wait();
876
877 Mem(MBvk,SIZE_MB).$set$(std::move(input), geometry);
878 geometry->ID.vert = geometry->id;
879 geometry->ID.index = -1;
880 int c = (int)inth.size();
881 inth["sprite" + std::to_string(c)] = (geometry->ID.vert);
882
883 return true;
884
885 };
log_obj
#define log_obj(...)
Definition: ObjectVk.h:13

◆ $createVertexInfo$()

template<typename Geom >
void ObjectsVk::$createVertexInfo$ ( Geom *  geometry,
int  type = 0 
)
inline

Definition at line 966 of file ObjectVk.h.

966 {
967 if (uint32_t(geometry->array.type) >= uint32_t(arth::INPUT::ALL_TYPE)) { log_bad("Bad Input Type Come.\n"); }
968 if (type == 1) {
969 $VInfo.$setSprite$(geometry);
970 }
971 else {
972 $VInfo.$set$(geometry);
973 };
974 };
log_bad
#define log_bad(...)
Definition: log.hpp:37

◆ createBufferView()

template<class Geom >
bool ObjectsVk::createBufferView ( Geom &  bach,
VkDeviceSize  offset = 0,
VkBufferUsageFlags  usage = VK_BUFFER_USAGE_VERTEX_BUFFER_BIT 
)
inline

VK_FORMAT_R32_SFLOAT;

Definition at line 420 of file ObjectVk.h.

421 {
422
423 VkBufferView texel_view;
424 VkBufferViewCreateInfo view_info = {};
425 view_info.sType = VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO;
426 view_info.pNext = NULL;
427 view_info.buffer = bach.vkBuffer;
428 view_info.format = bach.format;
429 view_info.offset = offset;
430 view_info.range = bach.size;
431 vkCreateBufferView($device, &view_info, NULL, &texel_view);
432 bach.vkView = texel_view;
433 log_obj("Create BufferView on ObjectsVk. bufferView %p\n", texel_view);
434
435 return true;
436
437 };

◆ Delete()

template<class Geom >
bool ObjectsVk::Delete ( Geom *  geometry)
inline

Definition at line 996 of file ObjectVk.h.

996 {
997
998 bool ok = true;
999 if (geometry->ID.index >= 0) {
1000 geometry->id = geometry->ID.index;
1001 ok &= Mem(MBvk,SIZE_MB).$delete$(geometry);
1002 geometry->ID.index = -1;
1003 };
1004
1005 if (geometry->ID.vert >= 0) {
1006 geometry->id = geometry->ID.vert;
1007 ok &= Mem(MBvk,SIZE_MB).$delete$(geometry);
1008 geometry->ID.vert = -1;
1009 };
1010
1011 return ok;
1012
1013 };

◆ DeleteIBm()

template<class Geom >
bool ObjectsVk::DeleteIBm ( Geom &  hach)
inline

Definition at line 1028 of file ObjectVk.h.

1028 {
1029
1030 bool ok = true;
1031 if (hach.id == -1)return ok;
1032 ok &= Mem(IBmvk, SIZE_IBmDev).$delete$(&hach);
1033
1034 return ok;
1035
1036 };

◆ DeleteM()

template<class Geom >
bool ObjectsVk::DeleteM ( Geom &  hach)
inline

Definition at line 1039 of file ObjectVk.h.

1039 {
1040
1041 bool ok = true;
1042 if (hach.id == -1)return ok;
1043 ok &= Mem(Mvk, SIZE_MDev).$delete$(&hach);
1044
1045 return ok;
1046
1047 };

◆ DeleteMB()

template<class Geom >
bool ObjectsVk::DeleteMB ( Geom &  hach)
inline

Definition at line 1017 of file ObjectVk.h.

1017 {
1018
1019 bool ok = true;
1020 if (hach.id == -1)return ok;
1021 ok &= Mem(MBvk, SIZE_MB).$delete$(&hach);
1022
1023 return ok;
1024
1025 };

◆ destroy()

void ObjectsVk::destroy ( )

Definition at line 45 of file ObjectVk.cpp.

45 {
46
47 for (auto &[name,i] : inth) {
48 Mem(MBvk, SIZE_MB).cache[i].dealloc();
49 };
50
51 for (auto& [name, i] : mth) {
52 Mem(Mvk, SIZE_MDev).cache[i].dealloc();
53 };
54
55
56inth.clear();
57mth.clear();
58
59};

◆ getBuffer()

template<class Geom >
bool ObjectsVk::getBuffer ( MBvk &  mem,
Geom *  geometry 
)
inline

Definition at line 984 of file ObjectVk.h.

984 {
985 geometry->id = geometry->ID.vert;
986 return Mem(MBvk,SIZE_MB).get(mem, geometry);
987 };

◆ getIndex()

template<class Geom >
bool ObjectsVk::getIndex ( MBvk &  mem,
Geom *  geometry 
)
inline

Definition at line 990 of file ObjectVk.h.

990 {
991 geometry->id = geometry->ID.index;
992 return Mem(MBvk,SIZE_MB).get(mem, geometry);
993 };

◆ getMemory()

template<class Geom >
bool ObjectsVk::getMemory ( Mvk &  mem,
Geom &  geometry 
)
inline

Definition at line 979 of file ObjectVk.h.

979 {
980 return Mem(Mvk, SIZE_MDev).get(mem, &geometry);
981 };

◆ getVertexInfo()

bool ObjectsVk::getVertexInfo ( VkPipelineVertexInputStateCreateInfo *&  info,
arth::INPUT  Ity 
)

Definition at line 60 of file ObjectVk.cpp.

60 {
61 if (uint32_t(Ity) >= uint32_t(arth::INPUT::ALL_TYPE)) { log_bad("Bad Input Type Come.\n"); }
62 return $VInfo.get(info, Ity);
63};

Member Data Documentation

◆ inth

tb_umapII ObjectsVk::inth

Definition at line 318 of file ObjectVk.h.

◆ mth

tb_umapII ObjectsVk::mth

Definition at line 317 of file ObjectVk.h.

◆ slim

SRWLOCK ObjectsVk::slim

Definition at line 313 of file ObjectVk.h.

The documentation for this struct was generated from the following files: