Half-Life-RTX
/
xash3d-fwgs
mirror of https://github.com/w23/xash3d-fwgs
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

vk: remove lots of obsolete code 

TriApi/dynamic stuff is still not passed to RT, but removing old code
makes it easier to reason about.
This commit is contained in:
Ivan Avdeev 2023-06-06 10:40:10 -07:00
parent 8e0a9ac4d4
commit 98f8300ca2
7 changed files with 43 additions and 438 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

29
ref/vk/vk_brush.c
View File

@ -502,6 +502,35 @@ static void brushDrawWater(vk_brush_model_t *bmodel, const cl_entity_t *ent, int
});
}
// FIXME use this
static void computeConveyorSpeed(const color24 rendercolor, int tex_index, vec2_t speed) {
float sy, cy;
float flConveyorSpeed = 0.0f;
float flRate, flAngle;
vk_texture_t *texture = findTexture( tex_index );
//gl_texture_t *texture;
// FIXME
/* if( ENGINE_GET_PARM( PARM_QUAKE_COMPATIBLE ) && RI.currententity == gEngfuncs.GetEntityByIndex( 0 ) ) */
/* { */
/* // same as doom speed */
/* flConveyorSpeed = -35.0f; */
/* } */
/* else */
{
flConveyorSpeed = (rendercolor.g<<8|rendercolor.b) / 16.0f;
if( rendercolor.r ) flConveyorSpeed = -flConveyorSpeed;
}
//texture = R_GetTexture( glState.currentTextures[glState.activeTMU] );
flRate = fabs( flConveyorSpeed ) / (float)texture->width;
flAngle = ( flConveyorSpeed >= 0 ) ? 180 : 0;
SinCos( flAngle * ( M_PI_F / 180.0f ), &sy, &cy );
speed[0] = cy * flRate;
speed[1] = sy * flRate;
}
/*
===============
R_TextureAnimation

24
ref/vk/vk_ray_accel.c
View File

@ -400,13 +400,6 @@ void RT_VkAccelShutdown(void) {
if (g_accel.tlas != VK_NULL_HANDLE)
vkDestroyAccelerationStructureKHR(vk_core.device, g_accel.tlas, NULL);
for (int i = 0; i < COUNTOF(g_ray_model_state.models_cache); ++i) {
vk_ray_model_t *model = g_ray_model_state.models_cache + i;
if (model->blas != VK_NULL_HANDLE)
vkDestroyAccelerationStructureKHR(vk_core.device, model->blas, NULL);
model->blas = VK_NULL_HANDLE;
}
VK_BufferDestroy(&g_accel.scratch_buffer);
VK_BufferDestroy(&g_accel.accels_buffer);
VK_BufferDestroy(&g_accel.tlas_geom_buffer);
@ -425,12 +418,6 @@ void RT_VkAccelNewMap(void) {
aloPoolDestroy(g_accel.accels_buffer_alloc);
g_accel.accels_buffer_alloc = aloPoolCreate(MAX_ACCELS_BUFFER, expected_accels, accels_alignment);
// Clear model cache
for (int i = 0; i < COUNTOF(g_ray_model_state.models_cache); ++i) {
vk_ray_model_t *model = g_ray_model_state.models_cache + i;
VK_RayModelDestroy(model);
}
// Recreate tlas
// Why here and not in init: to make sure that its memory is preserved. Map init will clear all memory regions.
{
@ -620,14 +607,3 @@ finalize:
Mem_Free(build_ranges);
return retval;
}
// Update animated materials
void RT_BlasUpdateMaterialsSubset(struct rt_blas_s *blas, const struct vk_render_geometry_s *geoms[], const int *geoms_indices, int geoms_indices_count) {
ASSERT(!"Not implemented");
}
// Clone materials with different base_color texture (sprites)
uint32_t RT_BlasOverrideMaterial(struct rt_blas_s *blas, int texture) {
ASSERT(!"Not implemented");
return -1;
}

4
ref/vk/vk_ray_internal.h
View File

@ -31,8 +31,6 @@ typedef struct vk_ray_model_s {
typedef struct Kusok vk_kusok_data_t;
typedef struct rt_draw_instance_s {
vk_ray_model_t *model_toremove;
VkDeviceAddress blas_addr;
uint32_t kusochki_offset;
matrix3x4 transform_row;
@ -81,8 +79,6 @@ typedef struct {
uint32_t scratch_offset; // for building dynamic blases
} frame;
vk_ray_model_t models_cache[MODEL_CACHE_SIZE];
} xvk_ray_model_state_t;
extern xvk_ray_model_state_t g_ray_model_state;

337
ref/vk/vk_ray_model.c
View File

@ -23,73 +23,6 @@ typedef struct rt_model_s {
rt_kusochki_t kusochki;
} rt_model_t;
static void returnModelToCache(vk_ray_model_t *model) {
ASSERT(model->cache_toremove.taken);
model->cache_toremove.taken = false;
}
static vk_ray_model_t *getModelFromCache(int num_geoms, int max_prims, const VkAccelerationStructureGeometryKHR *geoms) { //}, int size) {
vk_ray_model_t *model = NULL;
int i;
for (i = 0; i < ARRAYSIZE(g_ray_model_state.models_cache); ++i)
{
int j;
model = g_ray_model_state.models_cache + i;
if (model->cache_toremove.taken)
continue;
if (!model->blas)
break;
if (model->cache_toremove.num_geoms != num_geoms)
continue;
if (model->cache_toremove.max_prims != max_prims)
continue;
for (j = 0; j < num_geoms; ++j) {
if (model->cache_toremove.geoms[j].geometryType != geoms[j].geometryType)
break;
if (model->cache_toremove.geoms[j].flags != geoms[j].flags)
break;
if (geoms[j].geometryType == VK_GEOMETRY_TYPE_TRIANGLES_KHR) {
// TODO what else should we compare?
if (model->cache_toremove.geoms[j].geometry.triangles.maxVertex != geoms[j].geometry.triangles.maxVertex)
break;
ASSERT(model->cache_toremove.geoms[j].geometry.triangles.vertexStride == geoms[j].geometry.triangles.vertexStride);
ASSERT(model->cache_toremove.geoms[j].geometry.triangles.vertexFormat == geoms[j].geometry.triangles.vertexFormat);
ASSERT(model->cache_toremove.geoms[j].geometry.triangles.indexType == geoms[j].geometry.triangles.indexType);
} else {
PRINT_NOT_IMPLEMENTED_ARGS("Non-tri geometries are not implemented");
break;
}
}
if (j == num_geoms)
break;
}
if (i == ARRAYSIZE(g_ray_model_state.models_cache))
return NULL;
// if (model->size > 0)
// ASSERT(model->size >= size);
if (!model->cache_toremove.geoms) {
const size_t size = sizeof(*geoms) * num_geoms;
model->cache_toremove.geoms = Mem_Malloc(vk_core.pool, size);
memcpy(model->cache_toremove.geoms, geoms, size);
model->cache_toremove.num_geoms = num_geoms;
model->cache_toremove.max_prims = max_prims;
}
model->cache_toremove.taken = true;
return model;
}
static void applyMaterialToKusok(vk_kusok_data_t* kusok, const vk_render_geometry_t *geom, int override_texture_id) {
const int tex_id = override_texture_id > 0 ? override_texture_id : geom->texture;
const xvk_material_t *const mat = XVK_GetMaterialForTextureIndex( tex_id );
@ -126,158 +59,6 @@ static void applyMaterialToKusok(vk_kusok_data_t* kusok, const vk_render_geometr
kusok->material.tex_base_color = TEX_BASE_SKYBOX;
}
vk_ray_model_t* VK_RayModelCreate( vk_ray_model_init_t args ) {
VkAccelerationStructureGeometryKHR *geoms;
uint32_t *geom_max_prim_counts;
VkAccelerationStructureBuildRangeInfoKHR *geom_build_ranges;
const VkBuffer geometry_buffer = R_GeometryBuffer_Get();
const VkDeviceAddress buffer_addr = R_VkBufferGetDeviceAddress(geometry_buffer);
vk_ray_model_t *ray_model;
int max_prims = 0;
ASSERT(vk_core.rtx);
// FIXME don't touch allocator each frame many times pls
geoms = Mem_Calloc(vk_core.pool, args.model->num_geometries * sizeof(*geoms));
geom_max_prim_counts = Mem_Malloc(vk_core.pool, args.model->num_geometries * sizeof(*geom_max_prim_counts));
geom_build_ranges = Mem_Calloc(vk_core.pool, args.model->num_geometries * sizeof(*geom_build_ranges));
/* gEngine.Con_Reportf("Loading model %s, geoms: %d\n", args.model->debug_name, args.model->num_geometries); */
for (int i = 0; i < args.model->num_geometries; ++i) {
vk_render_geometry_t *mg = args.model->geometries + i;
const uint32_t prim_count = mg->element_count / 3;
max_prims += prim_count;
geom_max_prim_counts[i] = prim_count;
geoms[i] = (VkAccelerationStructureGeometryKHR)
{
.sType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_KHR,
.flags = VK_GEOMETRY_OPAQUE_BIT_KHR, // FIXME this is not true. incoming mode might have transparency eventually (and also dynamically)
.geometryType = VK_GEOMETRY_TYPE_TRIANGLES_KHR,
.geometry.triangles =
(VkAccelerationStructureGeometryTrianglesDataKHR){
.sType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR,
.indexType = VK_INDEX_TYPE_UINT16,
.maxVertex = mg->max_vertex,
.vertexFormat = VK_FORMAT_R32G32B32_SFLOAT,
.vertexStride = sizeof(vk_vertex_t),
.vertexData.deviceAddress = buffer_addr,
.indexData.deviceAddress = buffer_addr,
},
};
geom_build_ranges[i] = (VkAccelerationStructureBuildRangeInfoKHR) {
.primitiveCount = prim_count,
.primitiveOffset = mg->index_offset * sizeof(uint16_t),
.firstVertex = mg->vertex_offset,
};
}
// FIXME this is definitely not the right place. We should upload everything in bulk, and only then build blases in bulk too
vk_combuf_t *const combuf = R_VkStagingCommit();
{
const VkBufferMemoryBarrier bmb[] = { {
.sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,
.srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT,
//.dstAccessMask = VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_KHR, // FIXME
.dstAccessMask = VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_KHR | VK_ACCESS_SHADER_READ_BIT, // FIXME
.buffer = geometry_buffer,
.offset = 0, // FIXME
.size = VK_WHOLE_SIZE, // FIXME
} };
vkCmdPipelineBarrier(combuf->cmdbuf,
VK_PIPELINE_STAGE_TRANSFER_BIT,
//VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_KHR,
VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_KHR | VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR,
0, 0, NULL, ARRAYSIZE(bmb), bmb, 0, NULL);
}
{
as_build_args_t asrgs = {
.geoms = geoms,
.max_prim_counts = geom_max_prim_counts,
.build_ranges = geom_build_ranges,
.n_geoms = args.model->num_geometries,
.type = VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_KHR,
.dynamic = args.model->dynamic,
.debug_name = args.model->debug_name,
};
ray_model = getModelFromCache(args.model->num_geometries, max_prims, geoms); //, build_size.accelerationStructureSize);
if (!ray_model) {
gEngine.Con_Printf(S_ERROR "Ran out of model cache slots\n");
} else {
qboolean result;
asrgs.p_accel = &ray_model->blas;
asrgs.out_accel_addr = &ray_model->blas_addr;
asrgs.inout_size = &ray_model->cache_toremove.size;
DEBUG_BEGINF(combuf->cmdbuf, "build blas for %s", args.model->debug_name);
result = createOrUpdateAccelerationStructure(combuf, &asrgs);
DEBUG_END(combuf->cmdbuf);
if (!result)
{
gEngine.Con_Printf(S_ERROR "Could not build BLAS for %s\n", args.model->debug_name);
returnModelToCache(ray_model);
ray_model = NULL;
} else {
ray_model->kusochki_offset = ALO_ALLOC_FAILED;
ray_model->dynamic = args.model->dynamic;
}
}
}
Mem_Free(geom_build_ranges);
Mem_Free(geom_max_prim_counts);
Mem_Free(geoms); // TODO this can be cached within models_cache ??
//gEngine.Con_Reportf("Model %s (%p) created blas %p\n", args.model->debug_name, args.model, args.model->rtx.blas);
return ray_model;
}
void VK_RayModelDestroy( struct vk_ray_model_s *model ) {
ASSERT(vk_core.rtx);
if (model->blas != VK_NULL_HANDLE) {
//gEngine.Con_Reportf("Model %s destroying AS=%p blas_index=%d\n", model->debug_name, model->rtx.blas, blas_index);
vkDestroyAccelerationStructureKHR(vk_core.device, model->blas, NULL);
Mem_Free(model->cache_toremove.geoms);
memset(model, 0, sizeof(*model));
}
}
// TODO move this to vk_brush
static void computeConveyorSpeed(const color24 rendercolor, int tex_index, vec2_t speed) {
float sy, cy;
float flConveyorSpeed = 0.0f;
float flRate, flAngle;
vk_texture_t *texture = findTexture( tex_index );
//gl_texture_t *texture;
// FIXME
/* if( ENGINE_GET_PARM( PARM_QUAKE_COMPATIBLE ) && RI.currententity == gEngfuncs.GetEntityByIndex( 0 ) ) */
/* { */
/* // same as doom speed */
/* flConveyorSpeed = -35.0f; */
/* } */
/* else */
{
flConveyorSpeed = (rendercolor.g<<8|rendercolor.b) / 16.0f;
if( rendercolor.r ) flConveyorSpeed = -flConveyorSpeed;
}
//texture = R_GetTexture( glState.currentTextures[glState.activeTMU] );
flRate = fabs( flConveyorSpeed ) / (float)texture->width;
flAngle = ( flConveyorSpeed >= 0 ) ? 180 : 0;
SinCos( flAngle * ( M_PI_F / 180.0f ), &sy, &cy );
speed[0] = cy * flRate;
speed[1] = sy * flRate;
}
// TODO utilize uploadKusochki([1]) to avoid 2 copies of staging code
static qboolean uploadKusochkiSubset(const vk_ray_model_t *const model, const vk_render_model_t *const render_model, const int *geom_indexes, int geom_indexes_count) {
// TODO can we sort all animated geometries (in brush) to have only a single range here?
@ -315,39 +96,6 @@ static qboolean uploadKusochkiSubset(const vk_ray_model_t *const model, const vk
return true;
}
static qboolean uploadKusochki(const vk_ray_model_t *const model, const vk_render_model_t *const render_model) {
const vk_staging_buffer_args_t staging_args = {
.buffer = g_ray_model_state.kusochki_buffer.buffer,
.offset = model->kusochki_offset * sizeof(vk_kusok_data_t),
.size = render_model->num_geometries * sizeof(vk_kusok_data_t),
.alignment = 16,
};
const vk_staging_region_t kusok_staging = R_VkStagingLockForBuffer(staging_args);
if (!kusok_staging.ptr) {
gEngine.Con_Printf(S_ERROR "Couldn't allocate staging for %d kusochkov for model %s\n", render_model->num_geometries, render_model->debug_name);
return false;
}
vk_kusok_data_t *const kusochki = kusok_staging.ptr;
for (int i = 0; i < render_model->num_geometries; ++i) {
vk_render_geometry_t *geom = render_model->geometries + i;
applyMaterialToKusok(kusochki + i, geom, -1);
}
/* gEngine.Con_Reportf("model %s: geom=%d kuoffs=%d kustoff=%d kustsz=%d sthndl=%d\n", */
/* render_model->debug_name, */
/* render_model->num_geometries, */
/* model->kusochki_offset, */
/* staging_args.offset, staging_args.size, */
/* kusok_staging.handle */
/* ); */
R_VkStagingUnlock(kusok_staging.handle);
return true;
}
// TODO this material mapping is context dependent. I.e. different entity types might need different ray tracing behaviours for
// same render_mode/type and even texture.
static uint32_t materialModeFromRenderType(vk_render_type_e render_type) {
@ -378,81 +126,11 @@ static uint32_t materialModeFromRenderType(vk_render_type_e render_type) {
return MATERIAL_MODE_OPAQUE;
}
void VK_RayFrameAddModel( vk_ray_model_t *model, const vk_render_model_t *render_model) {
rt_draw_instance_t* draw_instance = g_ray_model_state.frame.instances + g_ray_model_state.frame.instances_count;
ASSERT(vk_core.rtx);
ASSERT(g_ray_model_state.frame.instances_count <= ARRAYSIZE(g_ray_model_state.frame.instances));
ASSERT(model->cache_toremove.num_geoms == render_model->num_geometries);
if (g_ray_model_state.frame.instances_count == ARRAYSIZE(g_ray_model_state.frame.instances)) {
gEngine.Con_Printf(S_ERROR "Ran out of AccelerationStructure slots\n");
return;
}
ASSERT(model->blas != VK_NULL_HANDLE);
// Upload kusochki for the first time
if (ALO_ALLOC_FAILED == model->kusochki_offset) {
const r_lifetime_t lifetime = model->dynamic ? LifetimeDynamic : LifetimeStatic;
const int count = render_model->num_geometries;
model->kusochki_offset = R_DEBuffer_Alloc(&g_ray_model_state.kusochki_alloc, lifetime, count, 1);
if (model->kusochki_offset == ALO_ALLOC_FAILED) {
gEngine.Con_Printf(S_ERROR "Maximum number of kusochki exceeded on model %s\n", render_model->debug_name);
return;
}
if (!uploadKusochki(model, render_model))
return;
} else {
/* FIXME move to RT_FrameAddModel if (!uploadKusochkiSubset(model, render_model, render_model->geometries_changed, render_model->geometries_changed_count)) */
/* return; */
}
// TODO needed for brush models only
// (? TODO studio models?)
for (int i = 0; i < render_model->dynamic_polylights_count; ++i) {
rt_light_add_polygon_t *const polylight = render_model->dynamic_polylights + i;
polylight->transform_row = (const matrix3x4*)render_model->deprecate.transform;
polylight->dynamic = true;
RT_LightAddPolygon(polylight);
}
draw_instance->model_toremove = model;
draw_instance->blas_addr = model->blas_addr;
draw_instance->kusochki_offset = model->kusochki_offset;
draw_instance->material_mode = materialModeFromRenderType(render_model->deprecate.render_type);
Vector4Copy(render_model->deprecate.color, draw_instance->color);
Matrix3x4_Copy(draw_instance->transform_row, render_model->deprecate.transform);
Matrix4x4_Copy(draw_instance->prev_transform_row, render_model->deprecate.prev_transform);
g_ray_model_state.frame.instances_count++;
}
void RT_RayModel_Clear(void) {
R_DEBuffer_Init(&g_ray_model_state.kusochki_alloc, MAX_KUSOCHKI / 2, MAX_KUSOCHKI / 2);
}
void XVK_RayModel_ClearForNextFrame( void ) {
// FIXME we depend on the fact that only a single frame can be in flight
// currently framectl waits for the queue to complete before returning
// so we can be sure here that previous frame is complete and we're free to
// destroy/reuse dynamic ASes from previous frame
for (int i = 0; i < g_ray_model_state.frame.instances_count; ++i) {
rt_draw_instance_t *instance = g_ray_model_state.frame.instances + i;
ASSERT(instance->blas_addr);
if (!instance->model_toremove)
continue;
if (!instance->model_toremove->dynamic)
continue;
returnModelToCache(instance->model_toremove);
instance->model_toremove = NULL;
}
g_ray_model_state.frame.instances_count = 0;
// TODO N frames in flight
@ -593,7 +271,20 @@ void RT_FrameAddModel( struct rt_model_s *model, rt_frame_add_model_t args ) {
}
}
draw_instance->model_toremove = NULL;
#if 0
// TODO needed for brush models only
// (? TODO studio models?)
for (int i = 0; i < render_model->dynamic_polylights_count; ++i) {
rt_light_add_polygon_t *const polylight = render_model->dynamic_polylights + i;
polylight->transform_row = (const matrix3x4*)render_model->deprecate.transform;
polylight->dynamic = true;
RT_LightAddPolygon(polylight);
}
/* FIXME move to RT_FrameAddModel if (!uploadKusochkiSubset(model, render_model, render_model->geometries_changed, render_model->geometries_changed_count)) */
/* return; */
#endif
draw_instance->blas_addr = model->blas_addr;
draw_instance->kusochki_offset = kusochki_offset;
draw_instance->material_mode = materialModeFromRenderType(args.render_type);

58
ref/vk/vk_render.c
View File

@ -641,34 +641,10 @@ void VK_RenderEndRTX( struct vk_combuf_s* combuf, VkImageView img_dst_view, VkIm
}
}
qboolean VK_RenderModelInit_old( vk_render_model_t *model ) {
if (vk_core.rtx && (g_render_state.current_frame_is_ray_traced || !model->dynamic)) {
// TODO runtime rtx switch: ???
const vk_ray_model_init_t args = {
.model = model,
};
model->ray_model = VK_RayModelCreate(args);
model->dynamic_polylights = NULL;
model->dynamic_polylights_count = 0;
Matrix4x4_LoadIdentity(model->deprecate.transform);
Matrix4x4_LoadIdentity(model->deprecate.prev_transform);
return !!model->ray_model;
}
// TODO pre-bake optimal draws
return true;
}
qboolean VK_RenderModelCreate( vk_render_model_t *model, vk_render_model_init_t args ) {
memset(model, 0, sizeof(*model));
Q_strncpy(model->debug_name, args.name, sizeof(model->debug_name));
// TODO these are dynamic and should be removed
Matrix4x4_LoadIdentity(model->deprecate.transform);
Matrix4x4_LoadIdentity(model->deprecate.prev_transform);
model->deprecate.render_type = kVkRenderTypeSolid;
Vector4Set(model->deprecate.color, 1, 1, 1, 1);
model->geometries = args.geometries;
model->num_geometries = args.geometries_count;
@ -685,9 +661,6 @@ qboolean VK_RenderModelCreate( vk_render_model_t *model, vk_render_model_init_t
}
void VK_RenderModelDestroy( vk_render_model_t* model ) {
if (model->ray_model)
VK_RayModelDestroy(model->ray_model);
if (model->dynamic_polylights)
Mem_Free(model->dynamic_polylights);
@ -781,37 +754,6 @@ static void submitToTraditionalRender( trad_submit_t args ) {
drawCmdPushDebugLabelEnd();
}
#if 0
void VK_RenderModelDraw_old( vk_render_model_t* model, int ent_index_prev_frame__toremove ) {
++g_render.stats.models_count;
// TODO track prev transform directly as a member in vk_render_model_t
if (g_render_state.current_frame_is_ray_traced) {
if (ent_index_prev_frame__toremove >= 0 && model != NULL) {
R_PrevFrame_SaveCurrentState( ent_index_prev_frame__toremove, model->deprecate.transform );
R_PrevFrame_ModelTransform( ent_index_prev_frame__toremove, model->deprecate.prev_transform );
}
else {
Matrix4x4_Copy( model->deprecate.prev_transform, model->deprecate.transform );
}
if (model->rt_model) {
RT_FrameAddModel(model->rt_model, (rt_frame_add_model_t){
.render_type = model->deprecate.render_type,
.transform = (const matrix3x4*)&model->deprecate.transform,
.prev_transform = (const matrix3x4*)&model->deprecate.prev_transform,
.color = &model->deprecate.color,
});
} else
VK_RayFrameAddModel(model->ray_model, model);
return;
}
submitToTraditionalRender( model, model->deprecate.transform, model->deprecate.color, model->deprecate.render_type, -1 );
}
#endif
void R_RenderModelDraw(const vk_render_model_t *model, r_model_draw_t args) {
++g_render.stats.models_count;

19
ref/vk/vk_render.h
View File

@ -116,30 +116,13 @@ typedef struct vk_render_model_s {
// TODO deprecate
qboolean dynamic;
// Non-NULL only for ray tracing
// TODO deprecate in favor of rt_model_s
struct vk_ray_model_s *ray_model;
// Polylights which need to be added per-frame dynamically
// Used for non-worldmodel brush models which are not static
// TODO this doesn't belong here at all
struct rt_light_add_polygon_s *dynamic_polylights;
int dynamic_polylights_count;
struct {
// TODO these two are dynamic, extract them to draw args?
vk_render_type_e render_type;
vec4_t color;
matrix4x4 transform;
// previous frame ObjectToWorld (model) matrix
matrix4x4 prev_transform;
// TODO potentially dynamic. extract to draw args?
} deprecate;
} vk_render_model_t;
qboolean VK_RenderModelInit_old( vk_render_model_t* model );
// Initialize model from scratch
typedef struct {
const char *name;
@ -149,8 +132,6 @@ typedef struct {
qboolean VK_RenderModelCreate( vk_render_model_t *model, vk_render_model_init_t args );
void VK_RenderModelDestroy( vk_render_model_t* model );
void VK_RenderModelDraw_old( vk_render_model_t* model, int ent_index_prev_frame__toremove );
typedef struct {
vk_render_type_e render_type;

10
ref/vk/vk_rtx.h
View File

@ -6,18 +6,8 @@
struct vk_render_model_s;
struct vk_ray_model_s;
typedef struct {
struct vk_render_model_s *model;
} vk_ray_model_init_t;
struct vk_ray_model_s *VK_RayModelCreate( vk_ray_model_init_t model_init );
void VK_RayModelDestroy( struct vk_ray_model_s *model );
void VK_RayFrameBegin( void );
// TODO how to improve this render vs ray model storage/interaction?
void VK_RayFrameAddModel(struct vk_ray_model_s *model, const struct vk_render_model_s *render_model);
typedef struct {
VkBuffer buffer;
uint32_t offset;