beamformer_internal.h (20407B)
1 /* See LICENSE for license details. */ 2 #ifndef BEAMFORMER_INTERNAL_H 3 #define BEAMFORMER_INTERNAL_H 4 5 #include "beamformer.h" 6 7 #include "util.h" 8 #include "opengl.h" 9 10 #include "generated/beamformer.c" 11 #include "generated/beamformer_core.c" 12 #include "generated/beamformer_shader_data.c" 13 14 #include "external/raylib/src/raylib.h" 15 #include "external/raylib/src/rlgl.h" 16 17 #define beamformer_info(s) str8("[info] " s "\n") 18 19 #define os_path_separator() (str8){.data = &os_system_info()->path_separator_byte, .length = 1} 20 21 typedef struct { u64 value[1]; } VulkanHandle; 22 23 typedef enum { 24 VulkanTimeline_Graphics, 25 VulkanTimeline_Compute, 26 VulkanTimeline_Transfer, 27 VulkanTimeline_Count, 28 } VulkanTimeline; 29 30 typedef enum { 31 VulkanShaderKind_Vertex, 32 VulkanShaderKind_Mesh, 33 VulkanShaderKind_Fragment, 34 VulkanShaderKind_Compute, 35 VulkanShaderKind_Count, 36 } VulkanShaderKind; 37 38 typedef enum { 39 VulkanImageUsage_None, 40 VulkanImageUsage_Colour, 41 VulkanImageUsage_DepthStencil, 42 VulkanImageUsage_Count, 43 } VulkanImageUsage; 44 45 typedef enum { 46 VulkanUsageFlag_ImageSampling = 1 << 0, 47 VulkanUsageFlag_HostReadWrite = 1 << 1, // NOTE: not valid on images 48 /* NOTE: uses: 49 * - image-image copy operations 50 * - buffer-buffer copy operations 51 */ 52 VulkanUsageFlag_TransferSource = 1 << 2, 53 VulkanUsageFlag_TransferDestination = 1 << 3, 54 } VulkanUsageFlags; 55 56 typedef struct { 57 VulkanShaderKind kind; 58 str8 text; 59 str8 name; 60 } VulkanPipelineCreateInfo; 61 62 typedef struct { 63 VulkanHandle handle; 64 u64 gpu_pointer; 65 i64 size; 66 67 // NOTE: only used for render models 68 u64 index_count; 69 } GPUBuffer; 70 71 typedef struct { 72 VulkanHandle image; 73 u32 width; 74 u32 height; 75 u32 samples; 76 u32 mip_map_levels; 77 // TODO(rnp): this is only here for importing from OpenGL, move it back into handle later 78 u64 memory_size; 79 } GPUImage; 80 81 typedef enum { 82 GPUVendor_AMD = 0x1002, 83 GPUVendor_NVIDIA = 0x10DE, 84 GPUVendor_Qualcomm = 0x5143, 85 GPUVendor_Intel = 0x8086, 86 } GPUVendor; 87 88 typedef struct { 89 str8 name; 90 GPUVendor vendor; 91 92 f32 timestamp_period_ns; 93 94 u32 max_compute_shared_memory_size; 95 u16 max_msaa_samples; 96 u16 subgroup_size; 97 98 b32 cooperative_matrix; 99 100 u32 max_image_dimension_2D; 101 // NOTE(rnp): vulkan compute will output to a buffer so this won't be relevant 102 u32 max_image_dimension_3D; 103 104 u64 gpu_heap_size; 105 u64 gpu_heap_used; 106 } GPUInfo; 107 108 typedef struct { 109 i64 size; 110 VulkanUsageFlags flags; 111 112 // NOTE(rnp): only required if buffer will be used on multiple timelines 113 VulkanTimeline *timelines_used; 114 u32 timeline_count; 115 116 OSHandle *export; 117 118 str8 label; 119 } GPUBufferAllocateInfo; 120 121 typedef struct { 122 GPUBuffer *gpu_buffer; 123 u64 offset; 124 u64 size; 125 } GPUMemoryBarrierInfo; 126 127 typedef struct { 128 GPUBuffer model; 129 u32 vertex_count; 130 u32 normals_offset; 131 } RenderModel; 132 133 typedef struct { 134 BeamformerShaderResourceKind kind; 135 VulkanHandle handle; 136 u32 slot; 137 } BeamformerShaderResourceInfo; 138 139 #include "threads.c" 140 #include "util_os_ui.c" 141 #include "util_os.c" 142 143 /////////////////////////// 144 // NOTE: vulkan layer API 145 DEBUG_IMPORT void vk_load(OSLibrary vulkan, Arena *memory, Stream *error); 146 147 DEBUG_IMPORT GPUInfo *vk_gpu_info(void); 148 149 DEBUG_IMPORT void vk_buffer_allocate(GPUBuffer *, GPUBufferAllocateInfo *info); 150 DEBUG_IMPORT void vk_buffer_release(GPUBuffer *); 151 DEBUG_IMPORT void vk_buffer_range_upload(GPUBuffer *, void *data, u64 offset, u64 size, b32 non_temporal); 152 DEBUG_IMPORT void vk_buffer_range_download(void *output, GPUBuffer *, u64 source_offset, u64 size, b32 non_temporal); 153 DEBUG_IMPORT u64 vk_round_up_to_sync_size(u64, u64 min); 154 155 // NOTE: images are 2D only, any other use case should just use a buffer and index in the shader 156 DEBUG_IMPORT void vk_image_allocate(GPUImage *, u32 width, u32 height, u32 mips, u32 samples, VulkanImageUsage usage, VulkanUsageFlags flags, OSHandle *export, str8 label); 157 DEBUG_IMPORT void vk_image_release(GPUImage *); 158 159 DEBUG_IMPORT void vk_render_model_allocate(GPUBuffer *, void *indices, u64 index_count, u64 model_size, str8 label); 160 DEBUG_IMPORT void vk_render_model_range_upload(GPUBuffer *, void *data, u64 offset, u64 size, b32 non_temporal); 161 DEBUG_IMPORT void vk_render_model_release(GPUBuffer *); 162 163 DEBUG_IMPORT void vk_bind_shader_resources(BeamformerShaderResourceInfo *infos, u64 info_count); 164 165 /* NOTE: Pipelines do not have bindings. Data should be passed using push constants. 166 * In particular the push constants should contain pointers to gpu memory using the 167 * BufferDeviceAddress extension. */ 168 // TODO(rnp): change this to accept SPIR-V directly and accept BakeParameters as specialization data 169 DEBUG_IMPORT VulkanHandle vk_pipeline(VulkanPipelineCreateInfo *infos, u32 count, u32 push_constants_size); 170 DEBUG_IMPORT b32 vk_pipeline_valid(VulkanHandle); 171 DEBUG_IMPORT void vk_pipeline_release(VulkanHandle); 172 173 DEBUG_IMPORT b32 vk_buffer_needs_sync(GPUBuffer *); 174 175 DEBUG_IMPORT VulkanHandle vk_create_semaphore(OSHandle *export); 176 177 DEBUG_IMPORT b32 vk_host_wait_timeline(VulkanTimeline timeline, u64 value, u64 timeout_ns); 178 DEBUG_IMPORT u64 vk_host_signal_timeline(VulkanTimeline timeline); 179 180 DEBUG_IMPORT VulkanHandle vk_command_begin(VulkanTimeline timeline); 181 DEBUG_IMPORT void vk_command_bind_pipeline(VulkanHandle command, VulkanHandle pipeline); 182 DEBUG_IMPORT void vk_command_buffer_memory_barriers(VulkanHandle command, GPUMemoryBarrierInfo *barriers, u64 count); 183 DEBUG_IMPORT void vk_command_clear_buffer(VulkanHandle command, GPUBuffer *buffer, u64 offset, u64 size, u32 clear_word); 184 DEBUG_IMPORT void vk_command_dispatch_compute(VulkanHandle command, uv3 dispatch); 185 DEBUG_IMPORT void vk_command_push_constants(VulkanHandle command, u32 offset, u32 size, void *values); 186 DEBUG_IMPORT void vk_command_timestamp(VulkanHandle command); 187 DEBUG_IMPORT void vk_command_wait_timeline(VulkanHandle command, VulkanTimeline timeline, u64 value); 188 // NOTE: extra semaphores only exist for synchronization with OpenGL and will be removed in the future 189 DEBUG_IMPORT u64 vk_command_end(VulkanHandle command, VulkanHandle wait_semaphore, VulkanHandle finished_semaphore); 190 191 DEBUG_IMPORT void vk_command_begin_rendering(VulkanHandle command, GPUImage *restrict colour, GPUImage *restrict depth, GPUImage *restrict resolve); 192 DEBUG_IMPORT void vk_command_draw(VulkanHandle command, GPUBuffer *model); 193 DEBUG_IMPORT void vk_command_scissor(VulkanHandle command, u32 width, u32 height, u32 x_offset, u32 y_offset); 194 DEBUG_IMPORT void vk_command_viewport(VulkanHandle command, f32 width, f32 height, f32 x_offset, f32 y_offset, f32 min_depth, f32 max_depth); 195 DEBUG_IMPORT void vk_command_end_rendering(VulkanHandle command); 196 197 DEBUG_IMPORT void vk_command_copy_buffer(VulkanHandle command, GPUBuffer *restrict destination, GPUBuffer *restrict source, u64 source_offset, i64 size); 198 199 // NOTE: returns array of valid timestamps + 1, first element is the count. 200 // Calling thread may stall until results available. 201 DEBUG_IMPORT u64 * vk_command_read_timestamps(VulkanTimeline timeline, Arena *arena); 202 203 #if BEAMFORMER_RENDERDOC_HOOKS 204 DEBUG_IMPORT void * vk_renderdoc_instance_handle(void); 205 206 DEBUG_IMPORT renderdoc_start_frame_capture_fn *start_frame_capture; 207 DEBUG_IMPORT renderdoc_set_capture_path_template_fn *set_capture_path_template; 208 DEBUG_IMPORT renderdoc_end_frame_capture_fn *end_frame_capture; 209 #define start_renderdoc_capture() do { \ 210 if (set_capture_path_template) set_capture_path_template("captures/ogl.rdc"); \ 211 if (start_frame_capture) start_frame_capture(vk_renderdoc_instance_handle(), 0); \ 212 } while(0) 213 #define end_renderdoc_capture() if (end_frame_capture) end_frame_capture(vk_renderdoc_instance_handle(), 0) 214 #define renderdoc_attached(...) (start_frame_capture != 0) 215 216 #else 217 #define start_renderdoc_capture(...) 218 #define end_renderdoc_capture(...) 219 #define renderdoc_attached(...) (0) 220 #endif 221 222 /////////////////////////////// 223 // NOTE: CUDA Library Bindings 224 225 #define cuda_supported() (cuda_init != cuda_init_stub) 226 #define CUDA_INIT_FN(name) void name(u32 *input_dims, u32 *decoded_dims) 227 typedef CUDA_INIT_FN(cuda_init_fn); 228 CUDA_INIT_FN(cuda_init_stub) {} 229 230 #define CUDA_REGISTER_BUFFERS_FN(name) void name(u32 *rf_data_ssbos, u32 rf_buffer_count, u32 raw_data_ssbo) 231 typedef CUDA_REGISTER_BUFFERS_FN(cuda_register_buffers_fn); 232 CUDA_REGISTER_BUFFERS_FN(cuda_register_buffers_stub) {} 233 234 #define CUDA_HILBERT_FN(name) void name(u32 input_buffer_idx, u32 output_buffer_idx) 235 typedef CUDA_HILBERT_FN(cuda_hilbert_fn); 236 CUDA_HILBERT_FN(cuda_hilbert_stub) {} 237 238 #define CUDA_SET_CHANNEL_MAPPING_FN(name) void name(i16 *channel_mapping) 239 typedef CUDA_SET_CHANNEL_MAPPING_FN(cuda_set_channel_mapping_fn); 240 CUDA_SET_CHANNEL_MAPPING_FN(cuda_set_channel_mapping_stub) {} 241 242 #define CUDALibraryProcedureList \ 243 X(hilbert, "cuda_hilbert") \ 244 X(init, "init_cuda_configuration") \ 245 X(register_buffers, "register_cuda_buffers") \ 246 X(set_channel_mapping, "cuda_set_channel_mapping") 247 248 #define X(name, ...) DEBUG_IMPORT cuda_## name ##_fn *cuda_## name; 249 CUDALibraryProcedureList 250 #undef X 251 252 ///////////////////////////////////// 253 // NOTE: Core Beamformer Definitions 254 255 #include "beamformer_compute_stats.c" 256 #include "beamformer_shared_memory.c" 257 258 typedef struct { 259 BeamformerFilterParameters parameters; 260 f32 time_delay; 261 i32 length; 262 GPUBuffer buffer; 263 } BeamformerFilter; 264 265 // X(kind, format, elements) 266 #define BEAMFORMER_COMPUTE_ARRAY_PARAMETERS_LIST \ 267 X(Hadamard, f16, BeamformerMaxChannelCount * BeamformerMaxChannelCount) \ 268 X(FocalVectors, v2, BeamformerMaxChannelCount) \ 269 X(SparseElements, i16, BeamformerMaxChannelCount) \ 270 X(TransmitReceiveOrientations, u16, BeamformerMaxChannelCount) \ 271 272 typedef enum { 273 #define X(k, ...) BeamformerComputeArrayParameterKind_##k, 274 BEAMFORMER_COMPUTE_ARRAY_PARAMETERS_LIST 275 #undef X 276 BeamformerComputeArrayParameterKind_Count 277 } BeamformerComputeArrayParameterKind; 278 279 // NOTE(rnp): only used to calculate offsets, never used directly 280 #define X(name, type, elements) alignas(64) type name[elements]; 281 typedef struct {BEAMFORMER_COMPUTE_ARRAY_PARAMETERS_LIST} BeamformerComputeArrayParameters; 282 #undef X 283 284 typedef struct { 285 uv3 layout; 286 uv3 dispatch; 287 BeamformerDataKind input_data_kind; 288 BeamformerDataKind output_data_kind; 289 BeamformerShaderBakeParameters bake; 290 } BeamformerShaderDescriptor; 291 292 typedef struct BeamformerComputePlan BeamformerComputePlan; 293 struct BeamformerComputePlan { 294 BeamformerComputePipeline pipeline; 295 296 VulkanHandle vulkan_pipelines[BeamformerMaxComputeShaderStages]; 297 298 u32 first_image_shader_index; 299 u32 channel_count; 300 u32 raw_channel_byte_stride; 301 302 u32 dirty_programs; 303 304 BeamformerAcquisitionKind acquisition_kind; 305 u32 acquisition_count; 306 BeamformerContrastMode contrast_mode; 307 308 u32 rf_size; 309 i32 hadamard_order; 310 b32 iq_pipeline; 311 312 m4 ui_voxel_transform; 313 // NOTE(rnp): final voxel transform determining frame dimensions 314 m4 voxel_transform; 315 // NOTE(rnp): final voxel transform used for beamforming 316 m4 das_voxel_transform; 317 318 iv3 output_points; 319 i32 average_frames; 320 321 // TODO(rnp): specialization constants 322 v2 xdc_element_pitch; 323 m4 xdc_transform; 324 325 GPUBuffer array_parameters; 326 327 BeamformerFilter filters[BeamformerFilterSlots]; 328 329 u128 shader_hashes[BeamformerMaxComputeShaderStages]; 330 BeamformerShaderDescriptor shader_descriptors[BeamformerMaxComputeShaderStages]; 331 332 BeamformerComputePlan *next; 333 }; 334 335 typedef struct { 336 u64 upload_complete_values[BeamformerMaxRawDataFramesInFlight]; 337 u64 compute_complete_values[BeamformerMaxRawDataFramesInFlight]; 338 339 GPUBuffer buffer; 340 341 u32 active_rf_size; 342 343 u64 timestamp; 344 345 u64 insertion_index; 346 u64 compute_index; 347 } BeamformerRFBuffer; 348 349 typedef struct { 350 BeamformerComputeStatsTable table; 351 f32 average_times[BeamformerShaderKind_Count]; 352 353 u64 last_rf_timer_count; 354 f32 rf_time_delta_average; 355 356 u32 latest_frame_index; 357 u32 latest_rf_index; 358 } ComputeShaderStats; 359 360 /* TODO(rnp): maybe this also gets used for CPU timing info as well */ 361 typedef enum { 362 ComputeTimingInfoKind_ComputeFrameBegin, 363 ComputeTimingInfoKind_ComputeFrameEnd, 364 ComputeTimingInfoKind_Shader, 365 ComputeTimingInfoKind_RF_Data, 366 } ComputeTimingInfoKind; 367 368 typedef struct { 369 u64 timer_count; 370 ComputeTimingInfoKind kind; 371 union { 372 struct { 373 static_assert(BeamformerShaderKind_Count <= U16_MAX, ""); 374 u16 shader; 375 u16 shader_slot; 376 }; 377 }; 378 } ComputeTimingInfo; 379 380 typedef struct { 381 u32 write_index; 382 u32 read_index; 383 b32 compute_frame_active; 384 385 u32 in_flight_shader_count; 386 BeamformerShaderKind in_flight_shader_ids[BeamformerMaxComputeShaderStages]; 387 388 ComputeTimingInfo buffer[4096]; 389 } ComputeTimingTable; 390 391 typedef struct { 392 BeamformerRFBuffer *rf_buffer; 393 BeamformerSharedMemory *shared_memory; 394 i64 shared_memory_size; 395 ComputeTimingTable *compute_timing_table; 396 i32 *compute_worker_sync; 397 } BeamformerUploadThreadContext; 398 399 typedef struct { 400 u64 buffer_offset; 401 u64 timeline_valid_value; 402 403 /* NOTE: for use when displaying either prebeamformed frames or on the current frame 404 * when we intend to recompute on the next frame */ 405 m4 voxel_transform; 406 407 iv3 points; 408 409 u32 id; 410 u32 compound_count; 411 u32 parameter_block; 412 BeamformerDataKind data_kind; 413 BeamformerAcquisitionKind acquisition_kind; 414 BeamformerContrastMode contrast_mode; 415 BeamformerViewPlaneTag view_plane_tag; 416 } BeamformerFrame; 417 418 /* NOTE(rnp): backing storage for beamformed frames. The amount of backlog frames 419 * is dependant on the currently requested output size. */ 420 typedef struct { 421 GPUBuffer buffer[1]; 422 423 u64 next_offset; 424 u64 counter; 425 426 BeamformerFrame frames[BeamformerMaxBacklogFrames]; 427 } BeamformerFrameBacklog; 428 429 typedef struct { 430 BeamformerRFBuffer rf_buffer; 431 432 BeamformerComputePlan *compute_plans[BeamformerMaxParameterBlocks]; 433 BeamformerComputePlan *compute_plan_freelist; 434 435 /* NOTE(rnp): used to ping pong data between compute stages. 436 * 437 * Allocate one extra slot for DAS output to allow overlap with the next 438 * channel chunk batch. To obtain optimal overlap we need 2 extra slots 439 * and we need to ping pong submissions between queues. This is not 440 * implemented so we only do 1 extra slot for now. 441 */ 442 #define PING_PONG_BUFFER_SLOTS (2 + 1) 443 GPUBuffer ping_pong_buffer; 444 OSHandle ping_pong_export_handle; 445 u32 ping_pong_input_index; 446 447 f32 processing_progress; 448 b32 processing_compute; 449 450 BeamformerFrameBacklog backlog; 451 } BeamformerComputeContext; 452 453 typedef struct { 454 OSThread handle; 455 456 Arena arena; 457 iptr user_context; 458 i32 sync_variable; 459 b32 awake; 460 } GLWorkerThreadContext; 461 462 typedef struct { 463 str8 name; 464 BeamformerRegisters *registers; 465 } BeamformerCommand; 466 467 typedef struct BeamformerRegistersNode BeamformerRegistersNode; 468 struct BeamformerRegistersNode { 469 BeamformerRegistersNode *next; 470 BeamformerRegisters v; 471 }; 472 473 typedef struct BeamformerCommandNode BeamformerCommandNode; 474 struct BeamformerCommandNode { 475 BeamformerCommandNode *next; 476 BeamformerCommandNode *prev; 477 BeamformerCommand command; 478 }; 479 480 typedef struct { 481 BeamformerCommandNode *first; 482 BeamformerCommandNode *last; 483 u64 count; 484 } BeamformerCommandList; 485 486 typedef enum { 487 BeamformerState_Uninitialized = 0, 488 BeamformerState_Running, 489 BeamformerState_ShouldClose, 490 BeamformerState_Terminated, 491 } BeamformerState; 492 493 typedef enum { 494 RulerState_None, 495 RulerState_Start, 496 RulerState_Hold, 497 RulerState_Count, 498 } RulerState; 499 500 typedef struct { 501 v3 start; 502 v3 end; 503 RulerState state; 504 } Ruler; 505 506 typedef struct { 507 f32 t; 508 f32 scale; 509 } BeamformerUIBlinker; 510 511 #define BEAMFORMER_FRAME_VIEW_KIND_LIST \ 512 X(Latest, "Latest") \ 513 X(3DXPlane, "3D X-Plane") \ 514 X(Copy, "Copy") \ 515 516 typedef enum { 517 #define X(kind, ...) BeamformerFrameViewKind_##kind, 518 BEAMFORMER_FRAME_VIEW_KIND_LIST 519 #undef X 520 BeamformerFrameViewKind_Count, 521 } BeamformerFrameViewKind; 522 523 typedef struct BeamformerFrameView BeamformerFrameView; 524 struct BeamformerFrameView { 525 BeamformerFrameViewKind kind; 526 b32 dirty; 527 528 // NOTE(rnp): for FrameViewKindCopy 529 GPUBuffer copy_buffer; 530 531 GPUImage colour_image; 532 // NOTE(rnp): temporary, on w32 we must hold onto this when importing vulkan data to OpenGL 533 OSHandle export_handle; 534 u32 memory_object; 535 u32 texture; 536 537 b32 log_scale; 538 f32 threshold; 539 f32 dynamic_range; 540 f32 gamma; 541 542 union { 543 /* BeamformerFrameViewKind_Latest/BeamformerFrameViewKind_Copy */ 544 struct { 545 b32 scale_bar_active[2]; 546 Ruler ruler; 547 BeamformerViewPlaneTag view_plane; 548 BeamformerFrame frame; 549 }; 550 551 /* BeamformerFrameViewKind_3DXPlane */ 552 struct { 553 f32 hot_t[BeamformerViewPlaneTag_Count]; 554 //b32 plane_active[BeamformerViewPlaneTag_Count]; 555 b32 plane_active[BeamformerViewPlaneTag_Count - 2]; 556 i32 plane_drag_index; 557 f32 rotation; 558 b32 demo; 559 v3 hit_start_point; 560 v3 hit_test_point; 561 }; 562 }; 563 564 BeamformerFrameView *prev, *next; 565 }; 566 567 typedef struct BeamformerUIPanel BeamformerUIPanel; 568 struct BeamformerUIPanel { 569 BeamformerUIPanel *parent; 570 BeamformerUIPanel *last_child; 571 BeamformerUIPanel *first_child; 572 BeamformerUIPanel *previous_sibling; 573 BeamformerUIPanel *next_sibling; 574 575 u64 child_count; 576 577 BeamformerPanelKind kind; 578 union { 579 BeamformerFrameView *frame_view; 580 581 BeamformerUIPanel *tab_focus; 582 583 BeamformerUIBlinker compute_stats_broken_shader_blinker; 584 BeamformerUIBlinker live_imaging_save_button_blinker; 585 586 struct { 587 u32 parameter_block; 588 b16 expand_coordinate[2]; 589 } parameter_listing; 590 591 struct { 592 Axis2 axis; 593 f32 fraction; 594 } split; 595 } u; 596 }; 597 598 typedef struct { 599 BeamformerState state; 600 601 iv2 window_size; 602 603 Arena arena; 604 Arena ui_backing_store; 605 void *ui; 606 u32 ui_dirty_parameter_blocks; 607 608 u64 frame_timestamp; 609 u64 frame_index; 610 Arena frame_arenas[2]; 611 TempArena frame_arena_savepoints[2]; 612 613 BeamformerUIPanel *auto_live_control_panel; 614 u64 live_imaging_active_frame; 615 b32 live_imaging_active; 616 617 BeamformerRegistersNode base_registers; 618 BeamformerRegistersNode *registers; 619 620 BeamformerCommandList command_queues[2]; 621 622 Stream error_stream; 623 624 BeamformerSharedMemory *shared_memory; 625 i64 shared_memory_size; 626 627 BeamformerFrame *latest_frame; 628 629 // TODO(rnp): track elsewhere 630 b32 render_shader_updated; 631 632 /* NOTE: this will only be used when we are averaging */ 633 u32 averaged_frame_index; 634 BeamformerFrame averaged_frames[2]; 635 636 GLWorkerThreadContext upload_worker; 637 GLWorkerThreadContext compute_worker; 638 639 BeamformerComputeContext compute_context; 640 641 ComputeShaderStats compute_shader_stats[1]; 642 ComputeTimingTable compute_timing_table[1]; 643 644 BeamformWorkQueue beamform_work_queue[1]; 645 646 // TODO(rnp): this should go to the UI eventually 647 OSWindow main_window; 648 } BeamformerCtx; 649 #define BeamformerContextMemory(m) (BeamformerCtx *)align_pointer_up((m), alignof(BeamformerCtx)); 650 651 typedef enum { 652 BeamformerFileReloadKind_ComputeInternalShader, 653 BeamformerFileReloadKind_ComputeShader, 654 BeamformerFileReloadKind_RenderShader, 655 } BeamformerFileReloadKind; 656 657 typedef struct { 658 BeamformerShaderKind shader; 659 VulkanHandle * pipeline; 660 } BeamformerShaderReloadData; 661 662 typedef struct { 663 BeamformerShaderKind shader; 664 VulkanShaderKind shader_kind; 665 666 // NOTE(rnp): based on BakeShaders compile time value 667 str8 filename_or_data; 668 669 BeamformerShaderDescriptor *shader_descriptor; 670 671 uv3 layout; 672 } BeamformerShaderReloadInfo; 673 674 typedef struct { 675 BeamformerFileReloadKind kind; 676 union { 677 BeamformerShaderReloadData shader_reload; 678 }; 679 } BeamformerFileReloadContext; 680 681 #define BEAMFORMER_COMPLETE_COMPUTE_FN(name) void name(BeamformerCtx *ctx, Arena *arena) 682 typedef BEAMFORMER_COMPLETE_COMPUTE_FN(beamformer_complete_compute_fn); 683 684 #define BEAMFORMER_RF_UPLOAD_FN(name) void name(BeamformerUploadThreadContext *ctx) 685 typedef BEAMFORMER_RF_UPLOAD_FN(beamformer_rf_upload_fn); 686 687 #define BEAMFORMER_DEBUG_UI_DEINIT_FN(name) void name(BeamformerCtx *ctx) 688 typedef BEAMFORMER_DEBUG_UI_DEINIT_FN(beamformer_debug_ui_deinit_fn); 689 690 #endif /* BEAMFORMER_INTERNAL_H */