2021-02-08 19:57:27 +01:00
|
|
|
#pragma once
|
|
|
|
#include "vk_common.h"
|
|
|
|
#include "vk_const.h"
|
2021-02-10 19:33:44 +01:00
|
|
|
#include "vk_core.h"
|
2021-02-08 19:57:27 +01:00
|
|
|
|
2021-02-20 21:00:31 +01:00
|
|
|
qboolean VK_RenderInit( void );
|
|
|
|
void VK_RenderShutdown( void );
|
2021-02-10 19:33:44 +01:00
|
|
|
|
2021-02-23 03:54:13 +01:00
|
|
|
typedef int vk_buffer_handle_t; // -1 == invalid handle
|
|
|
|
enum { InvalidHandle = -1 };
|
|
|
|
|
|
|
|
typedef struct {
|
2021-02-10 19:33:44 +01:00
|
|
|
void *ptr;
|
2021-02-23 03:54:13 +01:00
|
|
|
uint32_t unit_size, count;
|
|
|
|
} vk_buffer_lock_t;
|
|
|
|
|
|
|
|
typedef enum {
|
|
|
|
LifetimeLong,
|
|
|
|
LifetimeMap,
|
|
|
|
LifetimeSingleFrame,
|
|
|
|
} vk_lifetime_t;
|
|
|
|
|
|
|
|
// TODO: allocation lifetime with contents validity lifetime?
|
|
|
|
|
|
|
|
vk_buffer_handle_t VK_RenderBufferAlloc( uint32_t unit_size, uint32_t count, vk_lifetime_t lifetime );
|
|
|
|
vk_buffer_lock_t VK_RenderBufferLock( vk_buffer_handle_t handle );
|
|
|
|
void VK_RenderBufferUnlock( vk_buffer_handle_t handle );
|
2021-04-24 21:53:42 +02:00
|
|
|
uint32_t VK_RenderBufferGetOffsetInUnits( vk_buffer_handle_t handle );
|
2021-02-23 03:54:13 +01:00
|
|
|
|
|
|
|
// TODO buffer refcount when doing RTX AS updates? need to store buffer handles somewhere between frames
|
|
|
|
|
|
|
|
// Free all LifetimeSingleFrame resources
|
|
|
|
void VK_RenderBufferClearFrame( void );
|
|
|
|
|
|
|
|
// Free all LifetimeMap resources
|
|
|
|
void VK_RenderBufferClearMap( void );
|
2021-02-10 19:33:44 +01:00
|
|
|
|
2021-05-03 20:17:01 +02:00
|
|
|
// Mark map as loaded
|
|
|
|
void VK_RenderMapLoadEnd( void );
|
|
|
|
|
2021-02-10 19:33:44 +01:00
|
|
|
// TODO uploading to GPU mem interface
|
|
|
|
void VK_RenderBufferPrintStats( void );
|
2021-02-14 02:19:59 +01:00
|
|
|
|
2021-02-20 21:00:31 +01:00
|
|
|
// Set UBO state for next VK_RenderScheduleDraw calls
|
|
|
|
// Why? Xash Ref code is organized in a way where we can't reliably pass this info with
|
|
|
|
// ScheduleDraw itself, so we need to either set up per-submodule global state, or
|
|
|
|
// centralize this global state in here
|
|
|
|
void VK_RenderStateSetColor( float r, float g, float b, float a );
|
|
|
|
// TODO void VK_RenderStateGetColor( vec4_t color );
|
|
|
|
|
2021-03-13 22:35:50 +01:00
|
|
|
void VK_RenderStateSetMatrixProjection(const matrix4x4 proj);
|
|
|
|
void VK_RenderStateSetMatrixView(const matrix4x4 view);
|
|
|
|
void VK_RenderStateSetMatrixModel(const matrix4x4 model);
|
2021-03-03 20:58:40 +01:00
|
|
|
|
2021-03-14 01:33:17 +01:00
|
|
|
// TODO: radius, intensity, style, PVS bits, etc..
|
|
|
|
void VK_RenderAddStaticLight(vec3_t origin, vec3_t color);
|
|
|
|
|
2021-02-14 02:19:59 +01:00
|
|
|
// TODO is this a good place?
|
2021-02-17 22:26:09 +01:00
|
|
|
typedef struct vk_vertex_s {
|
2021-03-08 21:09:11 +01:00
|
|
|
// TODO padding needed for storage buffer reading, figure out how to fix in GLSL/SPV side
|
|
|
|
vec3_t pos; float p0_;
|
|
|
|
vec3_t normal; float p1_;
|
|
|
|
vec2_t gl_tc; //float p2_[2];
|
|
|
|
vec2_t lm_tc; //float p3_[2];
|
2021-02-17 22:26:09 +01:00
|
|
|
} vk_vertex_t;
|
2021-02-14 02:19:59 +01:00
|
|
|
|
2021-04-24 21:53:42 +02:00
|
|
|
typedef struct {
|
2021-02-23 03:54:13 +01:00
|
|
|
vk_buffer_handle_t index_buffer, vertex_buffer;
|
2021-04-24 21:53:42 +02:00
|
|
|
uint32_t index_offset, vertex_offset;
|
2021-02-14 02:19:59 +01:00
|
|
|
|
2021-04-24 21:53:42 +02:00
|
|
|
// TODO can be dynamic
|
2021-04-07 21:11:20 +02:00
|
|
|
int texture;
|
2021-04-24 21:53:42 +02:00
|
|
|
|
2021-04-07 21:11:20 +02:00
|
|
|
uint32_t element_count;
|
2021-04-09 23:59:04 +02:00
|
|
|
uint32_t vertex_count;
|
2021-04-24 21:53:42 +02:00
|
|
|
|
|
|
|
// TODO we don't really need this here
|
|
|
|
// as it's used to tie emissive surfaces to geometry in RTX renderer
|
|
|
|
// we can and should infer this dynamically (from texture) when building dynamic light clusters
|
2021-04-16 20:43:37 +02:00
|
|
|
int surface_index;
|
2021-04-07 21:11:20 +02:00
|
|
|
} vk_render_geometry_t;
|
|
|
|
|
2021-05-17 18:24:15 +02:00
|
|
|
struct vk_accel_s;
|
|
|
|
|
2021-04-09 23:59:04 +02:00
|
|
|
typedef struct vk_render_model_s {
|
2021-04-07 21:11:20 +02:00
|
|
|
const char *debug_name;
|
|
|
|
int render_mode;
|
|
|
|
int num_geometries;
|
|
|
|
vk_render_geometry_t *geometries;
|
|
|
|
|
|
|
|
// TODO potentially dynamic data: textures
|
2021-04-24 21:53:42 +02:00
|
|
|
|
|
|
|
// This model will be one-frame only, its buffers are not preserved between frames
|
|
|
|
qboolean dynamic;
|
2021-04-07 21:11:20 +02:00
|
|
|
|
|
|
|
struct {
|
2021-04-09 23:59:04 +02:00
|
|
|
VkAccelerationStructureKHR blas;
|
2021-04-10 21:46:37 +02:00
|
|
|
uint32_t kusochki_offset;
|
2021-05-17 18:24:15 +02:00
|
|
|
struct vk_accel_s *cache_accel;
|
2021-04-07 21:11:20 +02:00
|
|
|
} rtx;
|
|
|
|
} vk_render_model_t;
|
|
|
|
|
|
|
|
qboolean VK_RenderModelInit( vk_render_model_t* model );
|
|
|
|
void VK_RenderModelDestroy( vk_render_model_t* model );
|
|
|
|
void VK_RenderModelDraw( vk_render_model_t* model );
|
|
|
|
|
|
|
|
void VK_RenderFrameBegin( void );
|
|
|
|
|
2021-04-24 21:53:42 +02:00
|
|
|
void VK_RenderModelDynamicBegin( const char *debug_name, int render_mode );
|
|
|
|
void VK_RenderModelDynamicAddGeometry( const vk_render_geometry_t *geom );
|
|
|
|
void VK_RenderModelDynamicCommit( void );
|
2021-04-07 21:11:20 +02:00
|
|
|
|
|
|
|
void VK_RenderFrameEnd( VkCommandBuffer cmdbuf );
|
|
|
|
void VK_RenderFrameEndRTX( VkCommandBuffer cmdbuf, VkImageView img_dst_view, VkImage img_dst, uint32_t w, uint32_t h );
|
2021-02-20 21:35:04 +01:00
|
|
|
|
2021-04-24 21:53:42 +02:00
|
|
|
// void VK_RenderDebugLabelBegin( const char *label );
|
|
|
|
// void VK_RenderDebugLabelEnd( void );
|