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

#include <ObjectVk.h>

Public Member Functions

 VisibleObjectsVk ()
 
 ~VisibleObjectsVk ()
 
void destroy ()
 
template<class O >
bool get (MIBmvk &ubo, O *obj)
 
template<class Mem >
bool $AllocMemory$ (Mem &mach)
 
template<class Geom >
bool getMemory (Mvk &mem, Geom &geometry)
 
template<class Geom >
bool $createBufferSeparate$ (Geom &bach, VkDeviceMemory memory, VkBufferUsageFlags usage=VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT)
 
template<class O >
void $createBuffer$ (O &obj, VkBufferUsageFlags usage=VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, VkMemoryPropertyFlags memTy=VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT|VK_MEMORY_PROPERTY_HOST_COHERENT_BIT)
 
template<class O >
void $createTexelBuffer$ (O &obj)
 
template<class Geom >
bool $createBufferInstanced$ (Geom *&geometry, VkBufferUsageFlags usage=VK_BUFFER_USAGE_STORAGE_BUFFER_BIT|VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT|VK_BUFFER_USAGE_TRANSFER_DST_BIT)
 
template<class Geom >
bool $delete$ (Geom &bach)
 
template<class Geom >
bool $deleteIBM$ (Geom &bach)
 
template<class Geom >
bool DeleteM (Geom &hach)
 
template<class B >
bool erase (std::vector< long > &ve, B &ba)
 

Public Attributes

SRWLOCK slim
 
std::vector< long > uth
 
std::vector< long > mth
 
std::vector< long > ith
 

Detailed Description

Definition at line 1060 of file ObjectVk.h.

Constructor & Destructor Documentation

◆ VisibleObjectsVk()

VisibleObjectsVk::VisibleObjectsVk ( )

Definition at line 66 of file ObjectVk.cpp.

66 :uth(0) ,ith(0),mth(0){
67 InitializeSRWLock(&slim);
68};
VisibleObjectsVk::ith
std::vector< long > ith
Definition: ObjectVk.h:1065
VisibleObjectsVk::mth
std::vector< long > mth
Definition: ObjectVk.h:1064
VisibleObjectsVk::uth
std::vector< long > uth
Definition: ObjectVk.h:1063

◆ ~VisibleObjectsVk()

VisibleObjectsVk::~VisibleObjectsVk ( )

Definition at line 69 of file ObjectVk.cpp.

69{ destroy(); };

Member Function Documentation

◆ $AllocMemory$()

template<class Mem >
bool VisibleObjectsVk::$AllocMemory$ ( Mem &  mach)
inline

Definition at line 1078 of file ObjectVk.h.

1079 {
1080
1081 long orig = InterlockedCompareExchange(&(mach.id), INT32_MAX, -1);
1082 if (orig != -1) return false;
1083
1084 Mvk mem;
1085 {
1086
1087 VkMemoryRequirements memReqs = {};
1088 VkMemoryAllocateInfo memAlloc = {};
1089 memAlloc.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
1090
1091 VkBufferCreateInfo BufferInfo = {};
1092 VkBuffer buffer;
1093
1094 BufferInfo.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
1095 BufferInfo.usage = 0xff;
1096 VkDeviceSize offset = 0;
1097 mach.memSize = 0; memAlloc.allocationSize = 0;
1098 for (auto& v : mach.sizeSet) {
1099 BufferInfo.size = v;
1100 VK_CHECK_RESULT(vkCreateBuffer($device, &BufferInfo, nullptr, &buffer));
1101 vkGetBufferMemoryRequirements($device, buffer, &memReqs);
1102 vkDestroyBuffer($device, buffer, nullptr);
1103 memAlloc.allocationSize += memReqs.size;
1104 mach.memSize += BufferInfo.size;
1105 v = offset;
1106 offset += memReqs.size;
1107 };
1108 mach.reqSize = memAlloc.allocationSize;
1109 memAlloc.memoryTypeIndex = vka::shelve::getMemoryTypeIndex(memReqs.memoryTypeBits, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT);
1110
1111 VK_CHECK_RESULT(vkAllocateMemory($device, &memAlloc, nullptr, &mem.memory));
1112
1113
1114 VK_CHECK_RESULT(vkMapMemory($device, mem.memory, 0, mach.reqSize, 0, (void**)&mach.mapped));
1115
1116
1117
1118 };
1119
1120 Mem(Mvk, SIZE_MVis).$set$(std::move(mem), &mach.mem);
1121
1122
1123 AcquireSRWLockExclusive(&slim);
1124 mth.push_back(mach.mem.id);
1125 ReleaseSRWLockExclusive(&slim);
1126
1127 return true;
1128
1129 };
SIZE_MVis
#define SIZE_MVis
Definition: ObjectVk.h:19
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

◆ $createBuffer$()

template<class O >
void VisibleObjectsVk::$createBuffer$ ( O &  obj,
VkBufferUsageFlags  usage = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT,
VkMemoryPropertyFlags  memTy = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT 
)
inline

Definition at line 1182 of file ObjectVk.h.

1183 {
1184
1185 long orig = InterlockedCompareExchange(&(obj.buffer.id), INT32_MAX, -1);
1186 if (orig != -1) return;
1187
1188 MIBmvk ubo;
1189
1190 {
1191
1192 VkMemoryRequirements memReqs;
1193 VkMemoryAllocateInfo allocInfo = {};
1194
1195 allocInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
1196
1197 VkBufferCreateInfo BufferInfo = {};
1198 BufferInfo.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
1199 BufferInfo.size = obj.size;
1200 BufferInfo.usage = usage;
1201 VK_CHECK_RESULT(vkCreateBuffer($device, &BufferInfo, nullptr, &ubo.buffer));
1202 vkGetBufferMemoryRequirements($device, ubo.buffer, &memReqs);
1203 allocInfo.allocationSize = memReqs.size;
1204 allocInfo.memoryTypeIndex = vka::shelve::getMemoryTypeIndex(memReqs.memoryTypeBits,memTy );
1205
1206
1207 obj.reqAlign = memReqs.alignment;
1208 obj.reqSize = memReqs.size;
1209
1210
1211
1212 VK_CHECK_RESULT(vkAllocateMemory($device, &allocInfo, &$Policy_AllocateMemory, &(ubo.memory)));
1213 VK_CHECK_RESULT(vkBindBufferMemory($device, ubo.buffer, ubo.memory, 0));
1214
1215 ubo.info.buffer = obj.vkBuffer = ubo.buffer;
1216 ubo.info.offset = 0;
1217 ubo.info.range = obj.size;
1218
1219 VK_CHECK_RESULT(vkMapMemory($device, ubo.memory, 0, obj.size, 0, (void**)&ubo.mapped));
1220
1221 obj.mapped = ubo.mapped;
1222 log_obj(" Buffer Size %zu = [align %zu x ] ReqSize %zu = [reqAlign %zu ] \n", obj.size, obj.align, memReqs.size, memReqs.alignment);
1223
1224 }
1225
1226 Mem(MIBmvk, SIZE_MIBm).$set$(std::move(ubo), &obj.buffer);
1227
1228 AcquireSRWLockExclusive(&slim);
1229 uth.push_back(obj.buffer.id);
1230 ReleaseSRWLockExclusive(&slim);
1231
1232
1233 };
SIZE_MIBm
#define SIZE_MIBm
Definition: ObjectVk.h:23
log_obj
#define log_obj(...)
Definition: ObjectVk.h:13
MIBmvk::size
size_t size
Definition: vthreepy_types.h:204
MIBmvk::buffer
VkBuffer buffer
Definition: vthreepy_types.h:202
MIBmvk::info
VkDescriptorBufferInfo info
Definition: vthreepy_types.h:201
MIBmvk::mapped
void * mapped
Definition: vthreepy_types.h:203
MIBmvk::memory
VkDeviceMemory memory
Definition: vthreepy_types.h:200

◆ $createBufferInstanced$()

template<class Geom >
bool VisibleObjectsVk::$createBufferInstanced$ ( Geom *&  geometry,
VkBufferUsageFlags  usage = VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT 
)
inline

if (geometry->attributes != nullptr) $createBuffer$( geometry->attributes->buffer);

Definition at line 1316 of file ObjectVk.h.

1317 {
1318
1319 assert(geometry->instance != nullptr);
1320
1322
1323 long orig = InterlockedCompareExchange(&(geometry->instance->buffer->id), INT32_MAX, -1);
1324 if (orig != -1) return false;
1325
1326
1327 MIBmvk insta;
1328
1329 auto buf = geometry->instance->buffer;
1330 VkDeviceSize size = buf->array.memorySize;
1331 {
1332
1333 VkMemoryRequirements memReqs;
1334 VkMemoryAllocateInfo memAlloc = {};
1335 memAlloc.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
1336
1337 VkBufferCreateInfo BufferInfo = {};
1338 BufferInfo.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
1339 BufferInfo.size = size;
1340 BufferInfo.usage = VK_BUFFER_USAGE_VERTEX_BUFFER_BIT | usage;
1341
1342 VK_CHECK_RESULT(vkCreateBuffer($device, &BufferInfo, nullptr, &insta.buffer));
1343 vkGetBufferMemoryRequirements($device, insta.buffer, &memReqs);
1344 memAlloc.allocationSize = memReqs.size;
1345 memAlloc.memoryTypeIndex = vka::shelve::getMemoryTypeIndex(memReqs.memoryTypeBits, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT);
1346 VK_CHECK_RESULT(vkAllocateMemory($device, &memAlloc, nullptr, &insta.memory));
1347 VK_CHECK_RESULT(vkBindBufferMemory($device, insta.buffer, insta.memory, 0));
1348
1349 }
1350
1351 $VInfo.$setInstanced$(geometry);
1352
1353 VK_CHECK_RESULT(vkMapMemory($device, insta.memory, 0, size, 0, (void**)&insta.mapped));
1354
1355
1356
1357 geometry->instance->buffer->array.data = (char*)insta.mapped;
1358 geometry->instance->buffer->info.attr.buffer = insta.buffer;
1359 geometry->instance->buffer->info.attr.range = size;
1360 geometry->instance->buffer->info.attr.offset = 0;
1361
1362 Mem(MIBmvk, SIZE_MIBm).$set$(std::move(insta), geometry->instance->buffer);
1363
1364 AcquireSRWLockExclusive(&slim);
1365 uth.push_back(geometry->instance->buffer->id);
1366 ReleaseSRWLockExclusive(&slim);
1367
1368 return true;
1369
1370 };

◆ $createBufferSeparate$()

template<class Geom >
bool VisibleObjectsVk::$createBufferSeparate$ ( Geom &  bach,
VkDeviceMemory  memory,
VkBufferUsageFlags  usage = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT 
)
inline

Definition at line 1138 of file ObjectVk.h.

1139 {
1140
1141 long orig = InterlockedCompareExchange(&(bach.id), INT32_MAX, -1);
1142 if (orig != -1) return false;
1143
1144 IBmvk input;
1145 {
1146
1147 VkMemoryRequirements memReqs;
1148 VkMemoryAllocateInfo memAlloc = {};
1149 memAlloc.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
1150
1151 VkBufferCreateInfo BufferInfo = {};
1152 BufferInfo.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
1153 BufferInfo.size = bach.size;
1154 BufferInfo.usage = usage;
1155
1156 VK_CHECK_RESULT(vkCreateBuffer($device, &BufferInfo, nullptr, &input.buffer));
1157 vkGetBufferMemoryRequirements($device, input.buffer, &memReqs);
1158 bach.reqSize = memAlloc.allocationSize = memReqs.size;
1159 memAlloc.memoryTypeIndex = vka::shelve::getMemoryTypeIndex(memReqs.memoryTypeBits, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT);
1160
1161 VK_CHECK_RESULT(vkBindBufferMemory($device, input.buffer, memory, bach.offset));
1162
1163 };
1164
1165
1166 bach.vkBuffer = input.buffer;
1167 input.info.buffer = input.buffer;
1168 input.info.offset = 0;
1169 input.info.range = bach.size;
1170
1171
1172 Mem(IBmvk,SIZE_IBmVis).$set$(std::move(input), &bach.buffer);
1173 AcquireSRWLockExclusive(&slim);
1174 ith.push_back(bach.buffer.id);
1175 ReleaseSRWLockExclusive(&slim);
1176
1177 return true;
1178 };
SIZE_IBmVis
#define SIZE_IBmVis
Definition: ObjectVk.h:26
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

◆ $createTexelBuffer$()

template<class O >
void VisibleObjectsVk::$createTexelBuffer$ ( O &  obj)
inline

VkDeviceSize commit; vkGetDeviceMemoryCommitment($device, ubo.memory, &commit);

VK_FORMAT_R32_SFLOAT;

Definition at line 1237 of file ObjectVk.h.

1238 {
1239
1240 long orig = InterlockedCompareExchange(&(obj.buffer.id), INT32_MAX, -1);
1241 if (orig != -1) return;
1242
1243 MIBmvk ubo;
1244 {
1245
1246 VkMemoryRequirements memReqs;
1247 VkMemoryAllocateInfo allocInfo = {};
1248
1249 allocInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
1250
1251 VkBufferCreateInfo BufferInfo = {};
1252 BufferInfo.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
1253 BufferInfo.size = obj.size;
1254 BufferInfo.usage = VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT;
1255 VK_CHECK_RESULT(vkCreateBuffer($device, &BufferInfo, nullptr, &ubo.buffer));
1256 vkGetBufferMemoryRequirements($device, ubo.buffer, &memReqs);
1257 allocInfo.allocationSize = memReqs.size;
1258 allocInfo.memoryTypeIndex = vka::shelve::getMemoryTypeIndex(memReqs.memoryTypeBits, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT);
1259
1260
1261 obj.reqAlign = memReqs.alignment;
1262 obj.reqSize = memReqs.size;
1263
1264
1265
1266 VK_CHECK_RESULT(vkAllocateMemory($device, &allocInfo, &$Policy_AllocateMemory, &(ubo.memory)));
1267 VK_CHECK_RESULT(vkBindBufferMemory($device, ubo.buffer, ubo.memory, 0));
1268
1269
1272
1273
1274
1275
1276 // Store information in the uniform's descriptor that is used by the descriptor set
1277 ubo.info.buffer = ubo.buffer;
1278 ubo.info.offset = 0;
1279 ubo.info.range = obj.size;
1280
1281 VK_CHECK_RESULT(vkMapMemory($device, ubo.memory, 0, obj.size, 0, (void**)&ubo.mapped));
1282 obj.info = ubo.info;
1283 obj.mapped = ubo.mapped;
1284 log_obj(" Buffer Size %zu = [align %zu ] ReqSize %zu = [reqAlign %zu ] \n", obj.size, obj.align, memReqs.size, memReqs.alignment);
1285
1286 }
1287
1288
1289
1290 Mem(MIBmvk, SIZE_MIBm).$set$(std::move(ubo), &obj.buffer);
1291 AcquireSRWLockExclusive(&slim);
1292 uth.push_back(obj.buffer.id);
1293 ReleaseSRWLockExclusive(&slim);
1294
1295 {
1296
1297 VkBufferView texel_view;
1298 VkBufferViewCreateInfo view_info = {};
1299 view_info.sType = VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO;
1300 view_info.pNext = NULL;
1301 view_info.buffer = ubo.buffer;
1302 view_info.format = obj.format;
1303 view_info.offset = 0;
1304 view_info.range = obj.size;
1305
1306 vkCreateBufferView($device, &view_info, NULL, &texel_view);
1307
1308 obj.vkView = texel_view;
1309
1310
1311 };
1312
1313 };

◆ $delete$()

template<class Geom >
bool VisibleObjectsVk::$delete$ ( Geom &  bach)
inline

Definition at line 1375 of file ObjectVk.h.

1375 {
1376 if (!erase(uth, bach.buffer))return false;
1377 return Mem(MIBmvk, SIZE_MIBm).$delete$(&bach.buffer);
1378 };
VisibleObjectsVk::erase
bool erase(std::vector< long > &ve, B &ba)
Definition: ObjectVk.h:1400

◆ $deleteIBM$()

template<class Geom >
bool VisibleObjectsVk::$deleteIBM$ ( Geom &  bach)
inline

Definition at line 1382 of file ObjectVk.h.

1382 {
1383 if (!erase(ith, bach.buffer))return false;
1384 return Mem(IBmvk, SIZE_IBmVis).$delete$(&bach.buffer);
1385 };

◆ DeleteM()

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

Definition at line 1389 of file ObjectVk.h.

1389 {
1390
1391 if(!erase(mth, hach))return false;
1392 bool ok = true;
1393 if (hach.id == -1)return ok;
1394 ok &= Mem(Mvk, SIZE_MVis).$delete$(&hach);
1395
1396 return ok;
1397
1398 };

◆ destroy()

void VisibleObjectsVk::destroy ( )

Definition at line 70 of file ObjectVk.cpp.

70 {
71
72 for (long i : uth) {
73 Mem(MIBmvk, SIZE_MIBm).$kill$(i);
74 };
75
76 for (long i :ith){
77 Mem(IBmvk, SIZE_IBmVis).$kill$(i);
78 };
79
80 for (long i : mth){
81 Mem(Mvk, SIZE_MVis).$kill$(i);
82 };
83
84};

◆ erase()

template<class B >
bool VisibleObjectsVk::erase ( std::vector< long > &  ve,
B &  ba 
)
inline

Definition at line 1400 of file ObjectVk.h.

1400 {
1401 bool found = false;
1402 AcquireSRWLockExclusive(&slim);
1403 size_t N = ve.size();
1404 int i = 0;
1405 for (; i < N; i++) {
1406 if (ve[i] == ba.id) {
1407 found = true;
1408 break;
1409 }
1410 }
1411 ve.erase(ve.begin() + i);
1412 ReleaseSRWLockExclusive(&slim);
1413 return found;
1414 }

◆ get()

template<class O >
bool VisibleObjectsVk::get ( MIBmvk &  ubo,
O *  obj 
)
inline

Definition at line 1073 of file ObjectVk.h.

1073 {
1074 return Mem(MIBmvk, SIZE_MIBm).get(ubo, obj);
1075 };

◆ getMemory()

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

Definition at line 1133 of file ObjectVk.h.

1133 {
1134 return Mem( Mvk, SIZE_MVis).get(mem,&geometry);
1135 };

Member Data Documentation

◆ ith

std::vector<long> VisibleObjectsVk::ith

Definition at line 1065 of file ObjectVk.h.

◆ mth

std::vector<long> VisibleObjectsVk::mth

Definition at line 1064 of file ObjectVk.h.

◆ slim

SRWLOCK VisibleObjectsVk::slim

Definition at line 1062 of file ObjectVk.h.

◆ uth

std::vector<long> VisibleObjectsVk::uth

Definition at line 1063 of file ObjectVk.h.

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