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