kronos_compute/core/
structs.rs

1//! Core structures for Kronos API
2
3use std::ffi::{c_char, c_void};
4use std::ptr;
5use crate::sys::*;
6use crate::core::enums::*;
7use crate::core::flags::*;
8
9/// Helper for null-terminated string pointers
10pub type PtrCStr = *const c_char;
11
12/// 3D extent
13#[repr(C)]
14#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
15pub struct VkExtent3D {
16    pub width: u32,
17    pub height: u32,
18    pub depth: u32,
19}
20
21impl Default for VkExtent3D {
22    fn default() -> Self {
23        Self {
24            width: 1,
25            height: 1,
26            depth: 1,
27        }
28    }
29}
30
31/// Application information
32#[repr(C)]
33#[derive(Debug, Clone, Copy)]
34pub struct VkApplicationInfo {
35    pub sType: VkStructureType,
36    pub pNext: *const c_void,
37    pub pApplicationName: PtrCStr,
38    pub applicationVersion: u32,
39    pub pEngineName: PtrCStr,
40    pub engineVersion: u32,
41    pub apiVersion: u32,
42}
43
44impl Default for VkApplicationInfo {
45    fn default() -> Self {
46        Self {
47            sType: VkStructureType::ApplicationInfo,
48            pNext: ptr::null(),
49            pApplicationName: ptr::null(),
50            applicationVersion: 0,
51            pEngineName: ptr::null(),
52            engineVersion: 0,
53            apiVersion: VK_API_VERSION_1_0,
54        }
55    }
56}
57
58/// Instance creation information
59#[repr(C)]
60#[derive(Debug, Clone, Copy)]
61pub struct VkInstanceCreateInfo {
62    pub sType: VkStructureType,
63    pub pNext: *const c_void,
64    pub flags: VkInstanceCreateFlags,
65    pub pApplicationInfo: *const VkApplicationInfo,
66    pub enabledLayerCount: u32,
67    pub ppEnabledLayerNames: *const PtrCStr,
68    pub enabledExtensionCount: u32,
69    pub ppEnabledExtensionNames: *const PtrCStr,
70}
71
72impl Default for VkInstanceCreateInfo {
73    fn default() -> Self {
74        Self {
75            sType: VkStructureType::InstanceCreateInfo,
76            pNext: ptr::null(),
77            flags: 0,
78            pApplicationInfo: ptr::null(),
79            enabledLayerCount: 0,
80            ppEnabledLayerNames: ptr::null(),
81            enabledExtensionCount: 0,
82            ppEnabledExtensionNames: ptr::null(),
83        }
84    }
85}
86
87/// Queue family properties
88#[repr(C)]
89#[derive(Debug, Clone, Copy)]
90pub struct VkQueueFamilyProperties {
91    pub queueFlags: VkQueueFlags,
92    pub queueCount: u32,
93    pub timestampValidBits: u32,
94    pub minImageTransferGranularity: VkExtent3D,
95}
96
97/// Physical device features (compute-relevant only)
98#[repr(C)]
99#[derive(Debug, Clone, Copy)]
100pub struct VkPhysicalDeviceFeatures {
101    pub robustBufferAccess: VkBool32,
102    pub shaderFloat64: VkBool32,
103    pub shaderInt64: VkBool32,
104    pub shaderInt16: VkBool32,
105    pub shaderStorageBufferArrayDynamicIndexing: VkBool32,
106    pub shaderStorageImageArrayDynamicIndexing: VkBool32,
107    pub shaderStorageImageReadWithoutFormat: VkBool32,
108    pub shaderStorageImageWriteWithoutFormat: VkBool32,
109}
110
111impl Default for VkPhysicalDeviceFeatures {
112    fn default() -> Self {
113        Self {
114            robustBufferAccess: VK_FALSE,
115            shaderFloat64: VK_FALSE,
116            shaderInt64: VK_FALSE,
117            shaderInt16: VK_FALSE,
118            shaderStorageBufferArrayDynamicIndexing: VK_FALSE,
119            shaderStorageImageArrayDynamicIndexing: VK_FALSE,
120            shaderStorageImageReadWithoutFormat: VK_FALSE,
121            shaderStorageImageWriteWithoutFormat: VK_FALSE,
122        }
123    }
124}
125
126/// Device queue creation info
127#[repr(C)]
128#[derive(Debug, Clone, Copy)]
129pub struct VkDeviceQueueCreateInfo {
130    pub sType: VkStructureType,
131    pub pNext: *const c_void,
132    pub flags: VkDeviceQueueCreateFlags,
133    pub queueFamilyIndex: u32,
134    pub queueCount: u32,
135    pub pQueuePriorities: *const f32,
136}
137
138impl Default for VkDeviceQueueCreateInfo {
139    fn default() -> Self {
140        Self {
141            sType: VkStructureType::DeviceQueueCreateInfo,
142            pNext: ptr::null(),
143            flags: 0,
144            queueFamilyIndex: 0,
145            queueCount: 0,
146            pQueuePriorities: ptr::null(),
147        }
148    }
149}
150
151/// Device creation info
152#[repr(C)]
153#[derive(Debug, Clone, Copy)]
154pub struct VkDeviceCreateInfo {
155    pub sType: VkStructureType,
156    pub pNext: *const c_void,
157    pub flags: VkDeviceCreateFlags,
158    pub queueCreateInfoCount: u32,
159    pub pQueueCreateInfos: *const VkDeviceQueueCreateInfo,
160    pub enabledLayerCount: u32,
161    pub ppEnabledLayerNames: *const PtrCStr,
162    pub enabledExtensionCount: u32,
163    pub ppEnabledExtensionNames: *const PtrCStr,
164    pub pEnabledFeatures: *const VkPhysicalDeviceFeatures,
165}
166
167impl Default for VkDeviceCreateInfo {
168    fn default() -> Self {
169        Self {
170            sType: VkStructureType::DeviceCreateInfo,
171            pNext: ptr::null(),
172            flags: 0,
173            queueCreateInfoCount: 0,
174            pQueueCreateInfos: ptr::null(),
175            enabledLayerCount: 0,
176            ppEnabledLayerNames: ptr::null(),
177            enabledExtensionCount: 0,
178            ppEnabledExtensionNames: ptr::null(),
179            pEnabledFeatures: ptr::null(),
180        }
181    }
182}
183
184/// Memory type
185#[repr(C)]
186#[derive(Debug, Clone, Copy)]
187pub struct VkMemoryType {
188    pub propertyFlags: VkMemoryPropertyFlags,
189    pub heapIndex: u32,
190}
191
192/// Memory heap
193#[repr(C)]
194#[derive(Debug, Clone, Copy)]
195pub struct VkMemoryHeap {
196    pub size: VkDeviceSize,
197    pub flags: VkFlags,
198}
199
200/// Physical device memory properties
201#[repr(C)]
202#[derive(Debug, Clone, Copy)]
203pub struct VkPhysicalDeviceMemoryProperties {
204    pub memoryTypeCount: u32,
205    pub memoryTypes: [VkMemoryType; VK_MAX_MEMORY_TYPES],
206    pub memoryHeapCount: u32,
207    pub memoryHeaps: [VkMemoryHeap; VK_MAX_MEMORY_HEAPS],
208}
209
210impl Default for VkPhysicalDeviceMemoryProperties {
211    fn default() -> Self {
212        unsafe { std::mem::zeroed() }
213    }
214}
215
216/// Memory type cache for O(1) lookups
217#[repr(C)]
218#[derive(Debug, Clone, Copy, Default)]
219pub struct VkMemoryTypeCache {
220    pub hostVisibleCoherent: u32,
221    pub deviceLocal: u32,
222    pub hostVisibleCached: u32,
223    pub deviceLocalLazy: u32,
224}
225
226/// Memory allocate info
227#[repr(C)]
228#[derive(Debug, Clone, Copy)]
229pub struct VkMemoryAllocateInfo {
230    pub sType: VkStructureType,
231    pub pNext: *const c_void,
232    pub allocationSize: VkDeviceSize,
233    pub memoryTypeIndex: u32,
234}
235
236impl Default for VkMemoryAllocateInfo {
237    fn default() -> Self {
238        Self {
239            sType: VkStructureType::MemoryAllocateInfo,
240            pNext: ptr::null(),
241            allocationSize: 0,
242            memoryTypeIndex: 0,
243        }
244    }
245}
246
247/// Memory requirements
248#[repr(C)]
249#[derive(Debug, Clone, Copy)]
250pub struct VkMemoryRequirements {
251    pub size: VkDeviceSize,
252    pub alignment: VkDeviceSize,
253    pub memoryTypeBits: u32,
254}
255
256impl Default for VkMemoryRequirements {
257    fn default() -> Self {
258        Self {
259            size: 0,
260            alignment: 0,
261            memoryTypeBits: 0,
262        }
263    }
264}
265
266/// Fence creation info
267#[repr(C)]
268#[derive(Debug, Clone, Copy)]
269pub struct VkFenceCreateInfo {
270    pub sType: VkStructureType,
271    pub pNext: *const c_void,
272    pub flags: VkFenceCreateFlags,
273}
274
275impl Default for VkFenceCreateInfo {
276    fn default() -> Self {
277        Self {
278            sType: VkStructureType::FenceCreateInfo,
279            pNext: ptr::null(),
280            flags: VkFenceCreateFlags::empty(),
281        }
282    }
283}
284
285/// Semaphore creation info
286#[repr(C)]
287#[derive(Debug, Clone, Copy)]
288pub struct VkSemaphoreCreateInfo {
289    pub sType: VkStructureType,
290    pub pNext: *const c_void,
291    pub flags: VkFlags,
292}
293
294impl Default for VkSemaphoreCreateInfo {
295    fn default() -> Self {
296        Self {
297            sType: VkStructureType::SemaphoreCreateInfo,
298            pNext: ptr::null(),
299            flags: 0,
300        }
301    }
302}
303
304/// Event creation info
305#[repr(C)]
306#[derive(Debug, Clone, Copy)]
307pub struct VkEventCreateInfo {
308    pub sType: VkStructureType,
309    pub pNext: *const c_void,
310    pub flags: VkFlags,
311}
312
313impl Default for VkEventCreateInfo {
314    fn default() -> Self {
315        Self {
316            sType: VkStructureType::EventCreateInfo,
317            pNext: ptr::null(),
318            flags: 0,
319        }
320    }
321}
322
323/// Buffer creation info (optimized packing)
324#[repr(C)]
325#[derive(Debug, Clone, Copy)]
326pub struct VkBufferCreateInfo {
327    pub sType: VkStructureType,
328    pub pNext: *const c_void,
329    pub size: VkDeviceSize,
330    pub usage: VkBufferUsageFlags,
331    pub sharingMode: VkSharingMode,
332    pub queueFamilyIndexCount: u32,
333    pub pQueueFamilyIndices: *const u32,
334    pub flags: VkBufferCreateFlags,
335}
336
337impl Default for VkBufferCreateInfo {
338    fn default() -> Self {
339        Self {
340            sType: VkStructureType::BufferCreateInfo,
341            pNext: ptr::null(),
342            size: 0,
343            usage: VkBufferUsageFlags::empty(),
344            sharingMode: VkSharingMode::Exclusive,
345            queueFamilyIndexCount: 0,
346            pQueueFamilyIndices: ptr::null(),
347            flags: VkBufferCreateFlags::empty(),
348        }
349    }
350}
351
352/// Command pool creation info
353#[repr(C)]
354#[derive(Debug, Clone, Copy)]
355pub struct VkCommandPoolCreateInfo {
356    pub sType: VkStructureType,
357    pub pNext: *const c_void,
358    pub flags: VkCommandPoolCreateFlags,
359    pub queueFamilyIndex: u32,
360}
361
362impl Default for VkCommandPoolCreateInfo {
363    fn default() -> Self {
364        Self {
365            sType: VkStructureType::CommandPoolCreateInfo,
366            pNext: ptr::null(),
367            flags: VkCommandPoolCreateFlags::empty(),
368            queueFamilyIndex: 0,
369        }
370    }
371}
372
373/// Command buffer allocate info
374#[repr(C)]
375#[derive(Debug, Clone, Copy)]
376pub struct VkCommandBufferAllocateInfo {
377    pub sType: VkStructureType,
378    pub pNext: *const c_void,
379    pub commandPool: VkCommandPool,
380    pub level: VkCommandBufferLevel,
381    pub commandBufferCount: u32,
382}
383
384impl Default for VkCommandBufferAllocateInfo {
385    fn default() -> Self {
386        Self {
387            sType: VkStructureType::CommandBufferAllocateInfo,
388            pNext: ptr::null(),
389            commandPool: VkCommandPool::NULL,
390            level: VkCommandBufferLevel::Primary,
391            commandBufferCount: 0,
392        }
393    }
394}
395
396/// Command buffer begin info
397#[repr(C)]
398#[derive(Debug, Clone, Copy)]
399pub struct VkCommandBufferBeginInfo {
400    pub sType: VkStructureType,
401    pub pNext: *const c_void,
402    pub flags: VkCommandBufferUsageFlags,
403    pub pInheritanceInfo: *const c_void,
404}
405
406impl Default for VkCommandBufferBeginInfo {
407    fn default() -> Self {
408        Self {
409            sType: VkStructureType::CommandBufferBeginInfo,
410            pNext: ptr::null(),
411            flags: VkCommandBufferUsageFlags::empty(),
412            pInheritanceInfo: ptr::null(),
413        }
414    }
415}
416
417/// Memory barrier
418#[repr(C)]
419#[derive(Debug, Clone, Copy)]
420pub struct VkMemoryBarrier {
421    pub sType: VkStructureType,
422    pub pNext: *const c_void,
423    pub srcAccessMask: VkAccessFlags,
424    pub dstAccessMask: VkAccessFlags,
425}
426
427impl Default for VkMemoryBarrier {
428    fn default() -> Self {
429        Self {
430            sType: VkStructureType::MemoryBarrier,
431            pNext: ptr::null(),
432            srcAccessMask: VkAccessFlags::empty(),
433            dstAccessMask: VkAccessFlags::empty(),
434        }
435    }
436}
437
438/// Buffer memory barrier
439#[repr(C)]
440#[derive(Debug, Clone, Copy)]
441pub struct VkBufferMemoryBarrier {
442    pub sType: VkStructureType,
443    pub pNext: *const c_void,
444    pub srcAccessMask: VkAccessFlags,
445    pub dstAccessMask: VkAccessFlags,
446    pub srcQueueFamilyIndex: u32,
447    pub dstQueueFamilyIndex: u32,
448    pub buffer: VkBuffer,
449    pub offset: VkDeviceSize,
450    pub size: VkDeviceSize,
451}
452
453impl Default for VkBufferMemoryBarrier {
454    fn default() -> Self {
455        Self {
456            sType: VkStructureType::BufferMemoryBarrier,
457            pNext: ptr::null(),
458            srcAccessMask: VkAccessFlags::empty(),
459            dstAccessMask: VkAccessFlags::empty(),
460            srcQueueFamilyIndex: VK_QUEUE_FAMILY_IGNORED,
461            dstQueueFamilyIndex: VK_QUEUE_FAMILY_IGNORED,
462            buffer: VkBuffer::NULL,
463            offset: 0,
464            size: VK_WHOLE_SIZE,
465        }
466    }
467}
468
469/// Submit info
470#[repr(C)]
471#[derive(Debug, Clone, Copy)]
472pub struct VkSubmitInfo {
473    pub sType: VkStructureType,
474    pub pNext: *const c_void,
475    pub waitSemaphoreCount: u32,
476    pub pWaitSemaphores: *const VkSemaphore,
477    pub pWaitDstStageMask: *const VkPipelineStageFlags,
478    pub commandBufferCount: u32,
479    pub pCommandBuffers: *const VkCommandBuffer,
480    pub signalSemaphoreCount: u32,
481    pub pSignalSemaphores: *const VkSemaphore,
482}
483
484/// Buffer copy region
485#[repr(C)]
486#[derive(Debug, Clone, Copy)]
487pub struct VkBufferCopy {
488    pub srcOffset: VkDeviceSize,
489    pub dstOffset: VkDeviceSize,
490    pub size: VkDeviceSize,
491}
492
493impl Default for VkSubmitInfo {
494    fn default() -> Self {
495        Self {
496            sType: VkStructureType::SubmitInfo,
497            pNext: ptr::null(),
498            waitSemaphoreCount: 0,
499            pWaitSemaphores: ptr::null(),
500            pWaitDstStageMask: ptr::null(),
501            commandBufferCount: 0,
502            pCommandBuffers: ptr::null(),
503            signalSemaphoreCount: 0,
504            pSignalSemaphores: ptr::null(),
505        }
506    }
507}
508
509/// Physical device limits (simplified for compute)
510#[repr(C)]
511#[derive(Debug, Clone, Copy)]
512pub struct VkPhysicalDeviceLimits {
513    pub maxComputeSharedMemorySize: u32,
514    pub maxComputeWorkGroupCount: [u32; 3],
515    pub maxComputeWorkGroupInvocations: u32,
516    pub maxComputeWorkGroupSize: [u32; 3],
517    // Add more fields as needed...
518}
519
520impl Default for VkPhysicalDeviceLimits {
521    fn default() -> Self {
522        unsafe { std::mem::zeroed() }
523    }
524}
525
526/// Physical device sparse properties
527#[repr(C)]
528#[derive(Debug, Clone, Copy)]
529pub struct VkPhysicalDeviceSparseProperties {
530    pub residencyStandard2DBlockShape: VkBool32,
531    pub residencyStandard2DMultisampleBlockShape: VkBool32,
532    pub residencyStandard3DBlockShape: VkBool32,
533    pub residencyAlignedMipSize: VkBool32,
534    pub residencyNonResidentStrict: VkBool32,
535}
536
537impl Default for VkPhysicalDeviceSparseProperties {
538    fn default() -> Self {
539        unsafe { std::mem::zeroed() }
540    }
541}
542
543/// Physical device properties
544#[repr(C)]
545#[derive(Debug, Clone, Copy)]
546pub struct VkPhysicalDeviceProperties {
547    pub apiVersion: u32,
548    pub driverVersion: u32,
549    pub vendorID: u32,
550    pub deviceID: u32,
551    pub deviceType: VkPhysicalDeviceType,
552    pub deviceName: [c_char; VK_MAX_PHYSICAL_DEVICE_NAME_SIZE],
553    pub pipelineCacheUUID: [u8; VK_UUID_SIZE],
554    pub limits: VkPhysicalDeviceLimits,
555    pub sparseProperties: VkPhysicalDeviceSparseProperties,
556}
557
558impl Default for VkPhysicalDeviceProperties {
559    fn default() -> Self {
560        unsafe { std::mem::zeroed() }
561    }
562}
563
564#[cfg(test)]
565mod tests {
566    use super::*;
567    
568    #[test]
569    fn test_extent3d_default() {
570        let extent = VkExtent3D::default();
571        assert_eq!(extent.width, 1);
572        assert_eq!(extent.height, 1);
573        assert_eq!(extent.depth, 1);
574    }
575    
576    #[test]
577    fn test_application_info_default() {
578        let info = VkApplicationInfo::default();
579        assert_eq!(info.sType, VkStructureType::ApplicationInfo);
580        assert!(info.pNext.is_null());
581        assert!(info.pApplicationName.is_null());
582        assert_eq!(info.applicationVersion, 0);
583        assert_eq!(info.apiVersion, VK_API_VERSION_1_0);
584    }
585    
586    #[test]
587    fn test_instance_create_info_default() {
588        let info = VkInstanceCreateInfo::default();
589        assert_eq!(info.sType, VkStructureType::InstanceCreateInfo);
590        assert!(info.pNext.is_null());
591        assert_eq!(info.flags, 0);
592        assert_eq!(info.enabledLayerCount, 0);
593        assert_eq!(info.enabledExtensionCount, 0);
594    }
595    
596    #[test]
597    fn test_buffer_create_info_default() {
598        let info = VkBufferCreateInfo::default();
599        assert_eq!(info.sType, VkStructureType::BufferCreateInfo);
600        assert!(info.pNext.is_null());
601        assert_eq!(info.size, 0);
602        assert!(info.usage.is_empty());
603        assert_eq!(info.sharingMode, VkSharingMode::Exclusive);
604        assert!(info.flags.is_empty());
605    }
606    
607    #[test]
608    fn test_memory_allocate_info_default() {
609        let info = VkMemoryAllocateInfo::default();
610        assert_eq!(info.sType, VkStructureType::MemoryAllocateInfo);
611        assert!(info.pNext.is_null());
612        assert_eq!(info.allocationSize, 0);
613        assert_eq!(info.memoryTypeIndex, 0);
614    }
615    
616    #[test]
617    fn test_fence_create_info_default() {
618        let info = VkFenceCreateInfo::default();
619        assert_eq!(info.sType, VkStructureType::FenceCreateInfo);
620        assert!(info.pNext.is_null());
621        assert!(info.flags.is_empty());
622    }
623    
624    #[test]
625    fn test_submit_info_default() {
626        let info = VkSubmitInfo::default();
627        assert_eq!(info.sType, VkStructureType::SubmitInfo);
628        assert!(info.pNext.is_null());
629        assert_eq!(info.waitSemaphoreCount, 0);
630        assert_eq!(info.commandBufferCount, 0);
631        assert_eq!(info.signalSemaphoreCount, 0);
632    }
633    
634    #[test]
635    fn test_command_buffer_begin_info_default() {
636        let info = VkCommandBufferBeginInfo::default();
637        assert_eq!(info.sType, VkStructureType::CommandBufferBeginInfo);
638        assert!(info.pNext.is_null());
639        assert!(info.flags.is_empty());
640        assert!(info.pInheritanceInfo.is_null());
641    }
642    
643    #[test]
644    fn test_memory_barrier_default() {
645        let barrier = VkMemoryBarrier::default();
646        assert_eq!(barrier.sType, VkStructureType::MemoryBarrier);
647        assert!(barrier.pNext.is_null());
648        assert!(barrier.srcAccessMask.is_empty());
649        assert!(barrier.dstAccessMask.is_empty());
650    }
651    
652    #[test]
653    fn test_buffer_memory_barrier_default() {
654        let barrier = VkBufferMemoryBarrier::default();
655        assert_eq!(barrier.sType, VkStructureType::BufferMemoryBarrier);
656        assert!(barrier.pNext.is_null());
657        assert_eq!(barrier.srcQueueFamilyIndex, VK_QUEUE_FAMILY_IGNORED);
658        assert_eq!(barrier.dstQueueFamilyIndex, VK_QUEUE_FAMILY_IGNORED);
659        assert_eq!(barrier.size, VK_WHOLE_SIZE);
660    }
661}
kronos_compute/core/structs.rs

kronos_compute/core/
structs.rs
