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

vk: split devmem into a separate module 

prepare for a better device memory allocator
This commit is contained in:
Ivan Avdeev 2022-01-09 11:14:44 -08:00
parent 95ce46753e
commit 8f7f0d5c8e
13 changed files with 144 additions and 118 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
ref_vk/vk_2d.c
View File

@ -275,7 +275,7 @@ qboolean initVk2d( void )
if (!createPipelines())
return false;
if (!createBuffer("2d pics_buffer", &g2d.pics_buffer, sizeof(vertex_2d_t) * (MAX_PICS * 6),
if (!VK_BufferCreate("2d pics_buffer", &g2d.pics_buffer, sizeof(vertex_2d_t) * (MAX_PICS * 6),
VK_BUFFER_USAGE_VERTEX_BUFFER_BIT, VK_MEMORY_PROPERTY_HOST_COHERENT_BIT | VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT ))
// FIXME cleanup
return false;
@ -287,7 +287,7 @@ qboolean initVk2d( void )
void deinitVk2d( void )
{
destroyBuffer(&g2d.pics_buffer);
VK_BufferDestroy(&g2d.pics_buffer);
for (int i = 0; i < ARRAYSIZE(g2d.pipelines); ++i)
vkDestroyPipeline(vk_core.device, g2d.pipelines[i], NULL);

41
ref_vk/vk_buffer.c
View File

@ -2,7 +2,22 @@
#include <memory.h>
qboolean createBuffer(const char *debug_name, vk_buffer_t *buf, uint32_t size, VkBufferUsageFlags usage, VkMemoryPropertyFlags flags)
vk_global_buffer_t g_vk_buffers = {0};
#define DEFAULT_STAGING_SIZE (16*1024*1024)
qboolean VK_BuffersInit( void ) {
if (!VK_BufferCreate("staging", &g_vk_buffers.staging, DEFAULT_STAGING_SIZE, VK_BUFFER_USAGE_TRANSFER_SRC_BIT, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT))
return false;
return true;
}
void VK_BuffersDestroy( void ) {
VK_BufferDestroy(&g_vk_buffers.staging);
}
qboolean VK_BufferCreate(const char *debug_name, vk_buffer_t *buf, uint32_t size, VkBufferUsageFlags usage, VkMemoryPropertyFlags flags)
{
VkBufferCreateInfo bci = {
.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
@ -17,34 +32,32 @@ qboolean createBuffer(const char *debug_name, vk_buffer_t *buf, uint32_t size, V
vkGetBufferMemoryRequirements(vk_core.device, buf->buffer, &memreq);
gEngine.Con_Reportf("memreq: memoryTypeBits=0x%x alignment=%zu size=%zu\n", memreq.memoryTypeBits, memreq.alignment, memreq.size);
buf->device_memory = allocateDeviceMemory(memreq, flags, usage & VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT ? VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT : 0);
XVK_CHECK(vkBindBufferMemory(vk_core.device, buf->buffer, buf->device_memory.device_memory, buf->device_memory.offset));
buf->devmem = VK_DevMemAllocate(memreq, flags, usage & VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT ? VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT : 0);
XVK_CHECK(vkBindBufferMemory(vk_core.device, buf->buffer, buf->devmem.device_memory, buf->devmem.offset));
// FIXME when there are many allocation per VkDeviceMemory, fix this
if (VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT & flags)
XVK_CHECK(vkMapMemory(vk_core.device, buf->device_memory.device_memory, 0, bci.size, 0, &buf->mapped));
XVK_CHECK(vkMapMemory(vk_core.device, buf->devmem.device_memory, 0, bci.size, 0, &buf->mapped));
buf->size = size;
return true;
}
void destroyBuffer(vk_buffer_t *buf) {
// FIXME when there are many allocation per VkDeviceMemory, fix this
if (buf->buffer)
{
void VK_BufferDestroy(vk_buffer_t *buf) {
if (buf->buffer) {
vkDestroyBuffer(vk_core.device, buf->buffer, NULL);
buf->buffer = VK_NULL_HANDLE;
}
if (buf->device_memory.device_memory)
{
// FIXME when there are many allocation per VkDeviceMemory, fix this
if (buf->devmem.device_memory) {
if (buf->mapped)
vkUnmapMemory(vk_core.device, buf->device_memory.device_memory);
vkUnmapMemory(vk_core.device, buf->devmem.device_memory);
freeDeviceMemory(&buf->device_memory);
buf->device_memory.device_memory = VK_NULL_HANDLE;
buf->device_memory.offset = 0;
VK_DevMemFree(&buf->devmem);
buf->devmem.device_memory = VK_NULL_HANDLE;
buf->devmem.offset = 0;
buf->mapped = 0;
buf->size = 0;
}

25
ref_vk/vk_buffer.h
View File

@ -1,8 +1,27 @@
#pragma once
#include "vk_core.h"
qboolean createBuffer(const char *debug_name, vk_buffer_t *buf, uint32_t size, VkBufferUsageFlags usage, VkMemoryPropertyFlags flags);
void destroyBuffer(vk_buffer_t *buf);
#include "vk_core.h"
#include "vk_devmem.h"
typedef struct vk_buffer_s {
vk_devmem_t devmem;
VkBuffer buffer;
void *mapped;
uint32_t size;
} vk_buffer_t;
typedef struct {
vk_buffer_t staging;
} vk_global_buffer_t;
extern vk_global_buffer_t g_vk_buffers;
qboolean VK_BuffersInit( void );
void VK_BuffersDestroy( void );
qboolean VK_BufferCreate(const char *debug_name, vk_buffer_t *buf, uint32_t size, VkBufferUsageFlags usage, VkMemoryPropertyFlags flags);
void VK_BufferDestroy(vk_buffer_t *buf);
// v -- begin of ring buffer|permanent_size

51
ref_vk/vk_core.c
View File

@ -735,7 +735,7 @@ qboolean R_VkInit( void )
if (!createCommandPool())
return false;
if (!createBuffer("staging", &vk_core.staging, 16 * 1024 * 1024 /* TODO why 16Mb? */, VK_BUFFER_USAGE_TRANSFER_SRC_BIT, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT))
if (!VK_BuffersInit())
return false;
{
@ -822,7 +822,7 @@ void R_VkShutdown( void )
VK_DescriptorShutdown();
vkDestroySampler(vk_core.device, vk_core.default_sampler, NULL);
destroyBuffer(&vk_core.staging);
VK_BuffersDestroy();
vkDestroyCommandPool(vk_core.device, vk_core.command_pool, NULL);
@ -902,50 +902,3 @@ VkFence createFence( void ) {
void destroyFence(VkFence fence) {
vkDestroyFence(vk_core.device, fence, NULL);
}
static uint32_t findMemoryWithType(uint32_t type_index_bits, VkMemoryPropertyFlags flags) {
for (uint32_t i = 0; i < vk_core.physical_device.memory_properties2.memoryProperties.memoryTypeCount; ++i) {
if (!(type_index_bits & (1 << i)))
continue;
if ((vk_core.physical_device.memory_properties2.memoryProperties.memoryTypes[i].propertyFlags & flags) == flags)
return i;
}
return UINT32_MAX;
}
device_memory_t allocateDeviceMemory(VkMemoryRequirements req, VkMemoryPropertyFlags props, VkMemoryAllocateFlags flags) {
// TODO coalesce allocations, ...
device_memory_t ret = {0};
const VkMemoryAllocateFlagsInfo mafi = {
.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO,
.flags = flags,
};
const VkMemoryAllocateInfo mai = {
.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO,
.pNext = flags ? &mafi : NULL,
.allocationSize = req.size,
.memoryTypeIndex = findMemoryWithType(req.memoryTypeBits, props),
};
gEngine.Con_Reportf("allocateDeviceMemory size=%zu memoryTypeBits=0x%x memoryProperties=%c%c%c%c%c flags=0x%x => typeIndex=%d\n", req.size, req.memoryTypeBits,
props & VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT ? 'D' : '.',
props & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT ? 'V' : '.',
props & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT ? 'C' : '.',
props & VK_MEMORY_PROPERTY_HOST_CACHED_BIT ? '$' : '.',
props & VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT ? 'L' : '.',
flags,
mai.memoryTypeIndex);
ASSERT(mai.memoryTypeIndex != UINT32_MAX);
XVK_CHECK(vkAllocateMemory(vk_core.device, &mai, NULL, &ret.device_memory));
return ret;
}
void freeDeviceMemory(device_memory_t *mem)
{
vkFreeMemory(vk_core.device, mem->device_memory, NULL);
}

21
ref_vk/vk_core.h
View File

@ -17,25 +17,6 @@ void destroySemaphore(VkSemaphore sema);
VkFence createFence( void );
void destroyFence(VkFence fence);
// FIXME arena allocation, ...
typedef struct device_memory_s
{
VkDeviceMemory device_memory;
uint32_t offset;
} device_memory_t;
device_memory_t allocateDeviceMemory(VkMemoryRequirements req, VkMemoryPropertyFlags props, VkMemoryAllocateFlags flags);
void freeDeviceMemory(device_memory_t *mem);
typedef struct vk_buffer_s
{
device_memory_t device_memory;
VkBuffer buffer;
void *mapped;
uint32_t size;
} vk_buffer_t;
typedef struct physical_device_s {
VkPhysicalDevice device;
VkPhysicalDeviceMemoryProperties2 memory_properties2;
@ -74,8 +55,6 @@ typedef struct vulkan_core_s {
VkCommandBuffer cb;
VkCommandBuffer cb_tex;
vk_buffer_t staging;
VkSampler default_sampler;
unsigned int num_devices;

48
ref_vk/vk_devmem.c Normal file
View File

@ -0,0 +1,48 @@
#include "vk_devmem.h"
static uint32_t findMemoryWithType(uint32_t type_index_bits, VkMemoryPropertyFlags flags) {
for (uint32_t i = 0; i < vk_core.physical_device.memory_properties2.memoryProperties.memoryTypeCount; ++i) {
if (!(type_index_bits & (1 << i)))
continue;
if ((vk_core.physical_device.memory_properties2.memoryProperties.memoryTypes[i].propertyFlags & flags) == flags)
return i;
}
return UINT32_MAX;
}
vk_devmem_t VK_DevMemAllocate(VkMemoryRequirements req, VkMemoryPropertyFlags props, VkMemoryAllocateFlags flags) {
// TODO coalesce allocations, ...
vk_devmem_t ret = {0};
const VkMemoryAllocateFlagsInfo mafi = {
.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO,
.flags = flags,
};
const VkMemoryAllocateInfo mai = {
.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO,
.pNext = flags ? &mafi : NULL,
.allocationSize = req.size,
.memoryTypeIndex = findMemoryWithType(req.memoryTypeBits, props),
};
gEngine.Con_Reportf("allocateDeviceMemory size=%zu memoryTypeBits=0x%x memoryProperties=%c%c%c%c%c flags=0x%x => typeIndex=%d\n", req.size, req.memoryTypeBits,
props & VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT ? 'D' : '.',
props & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT ? 'V' : '.',
props & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT ? 'C' : '.',
props & VK_MEMORY_PROPERTY_HOST_CACHED_BIT ? '$' : '.',
props & VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT ? 'L' : '.',
flags,
mai.memoryTypeIndex);
ASSERT(mai.memoryTypeIndex != UINT32_MAX);
XVK_CHECK(vkAllocateMemory(vk_core.device, &mai, NULL, &ret.device_memory));
return ret;
}
void VK_DevMemFree(vk_devmem_t *mem) {
vkFreeMemory(vk_core.device, mem->device_memory, NULL);
mem->device_memory = VK_NULL_HANDLE;
}

11
ref_vk/vk_devmem.h Normal file
View File

@ -0,0 +1,11 @@
#pragma once
#include "vk_core.h"
// FIXME arena allocation, ...
typedef struct vk_devmem_s {
VkDeviceMemory device_memory;
uint32_t offset;
} vk_devmem_t;
vk_devmem_t VK_DevMemAllocate(VkMemoryRequirements req, VkMemoryPropertyFlags props, VkMemoryAllocateFlags flags);
void VK_DevMemFree(vk_devmem_t *mem);

13
ref_vk/vk_framectl.c
View File

@ -5,6 +5,7 @@
#include "vk_render.h"
#include "vk_rtx.h"
#include "vk_cvar.h"
#include "vk_devmem.h"
#include "profiler.h"
@ -17,7 +18,7 @@ vk_framectl_t vk_frame = {0};
static struct {
struct {
VkFormat format;
device_memory_t device_memory;
vk_devmem_t device_memory;
VkImage image;
VkImageView image_view;
} depth;
@ -111,7 +112,7 @@ static void createDepthImage(int w, int h) {
SET_DEBUG_NAME(g_frame.depth.image, VK_OBJECT_TYPE_IMAGE, "depth buffer");
vkGetImageMemoryRequirements(vk_core.device, g_frame.depth.image, &memreq);
g_frame.depth.device_memory = allocateDeviceMemory(memreq, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, 0);
g_frame.depth.device_memory = VK_DevMemAllocate(memreq, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, 0);
XVK_CHECK(vkBindImageMemory(vk_core.device, g_frame.depth.image, g_frame.depth.device_memory.device_memory, 0));
{
@ -129,7 +130,7 @@ static void createDepthImage(int w, int h) {
static void destroyDepthImage( void ) {
vkDestroyImageView(vk_core.device, g_frame.depth.image_view, NULL);
vkDestroyImage(vk_core.device, g_frame.depth.image, NULL);
freeDeviceMemory(&g_frame.depth.device_memory);
VK_DevMemFree(&g_frame.depth.device_memory);
}
static VkRenderPass createRenderPass( qboolean ray_tracing ) {
@ -575,7 +576,7 @@ static rgbdata_t *XVK_ReadPixels( void ) {
const VkFormat dest_format = VK_FORMAT_R8G8B8A8_UNORM;
VkImage dest_image;
VkImage frame_image;
device_memory_t dest_devmem;
vk_devmem_t dest_devmem;
rgbdata_t *r_shot = NULL;
const int
width = vk_frame.width,
@ -610,7 +611,7 @@ static rgbdata_t *XVK_ReadPixels( void ) {
{
VkMemoryRequirements memreq;
vkGetImageMemoryRequirements(vk_core.device, dest_image, &memreq);
dest_devmem = allocateDeviceMemory(memreq, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_CACHED_BIT, 0);
dest_devmem = VK_DevMemAllocate(memreq, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_CACHED_BIT, 0);
XVK_CHECK(vkBindImageMemory(vk_core.device, dest_image, dest_devmem.device_memory, dest_devmem.offset));
}
@ -792,7 +793,7 @@ static rgbdata_t *XVK_ReadPixels( void ) {
}
vkDestroyImage(vk_core.device, dest_image, NULL);
freeDeviceMemory(&dest_devmem);
VK_DevMemFree(&dest_devmem);
return r_shot;
}

4
ref_vk/vk_image.c
View File

@ -28,7 +28,7 @@ xvk_image_t XVK_ImageCreate(const xvk_image_create_t *create) {
SET_DEBUG_NAME(image.image, VK_OBJECT_TYPE_IMAGE, create->debug_name);
vkGetImageMemoryRequirements(vk_core.device, image.image, &memreq);
image.devmem = allocateDeviceMemory(memreq, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, 0);
image.devmem = VK_DevMemAllocate(memreq, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, 0);
XVK_CHECK(vkBindImageMemory(vk_core.device, image.image, image.devmem.device_memory, 0));
ivci.viewType = create->is_cubemap ? VK_IMAGE_VIEW_TYPE_CUBE : VK_IMAGE_VIEW_TYPE_2D;
@ -55,6 +55,6 @@ xvk_image_t XVK_ImageCreate(const xvk_image_create_t *create) {
void XVK_ImageDestroy(xvk_image_t *img) {
vkDestroyImageView(vk_core.device, img->view, NULL);
vkDestroyImage(vk_core.device, img->image, NULL);
freeDeviceMemory(&img->devmem);
VK_DevMemFree(&img->devmem);
*img = (xvk_image_t){0};
}

3
ref_vk/vk_image.h
View File

@ -1,10 +1,11 @@
#pragma once
#include "vk_core.h"
#include "vk_devmem.h"
typedef struct {
// FIXME better memory allocation
// OCHEN PLOHO
device_memory_t devmem;
vk_devmem_t devmem;
VkImage image;
VkImageView view;

8
ref_vk/vk_render.c
View File

@ -234,12 +234,12 @@ qboolean VK_RenderInit( void )
// TODO device memory and friends (e.g. handle mobile memory ...)
if (!createBuffer("render buffer", &g_render.buffer, vertex_buffer_size + index_buffer_size,
if (!VK_BufferCreate("render buffer", &g_render.buffer, vertex_buffer_size + index_buffer_size,
VK_BUFFER_USAGE_INDEX_BUFFER_BIT | VK_BUFFER_USAGE_VERTEX_BUFFER_BIT | (vk_core.rtx ? VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT | VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR : 0),
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT | (vk_core.rtx ? VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT : 0))) // TODO staging buffer?
return false;
if (!createBuffer("render uniform_buffer", &g_render.uniform_buffer, uniform_unit_size * MAX_UNIFORM_SLOTS,
if (!VK_BufferCreate("render uniform_buffer", &g_render.uniform_buffer, uniform_unit_size * MAX_UNIFORM_SLOTS,
VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT,
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT | (vk_core.rtx ? VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT : 0))) // TODO staging buffer?
return false;
@ -289,8 +289,8 @@ void VK_RenderShutdown( void )
vkDestroyPipeline(vk_core.device, g_render.pipelines[i], NULL);
vkDestroyPipelineLayout( vk_core.device, g_render.pipeline_layout, NULL );
destroyBuffer( &g_render.buffer );
destroyBuffer( &g_render.uniform_buffer );
VK_BufferDestroy( &g_render.buffer );
VK_BufferDestroy( &g_render.uniform_buffer );
}
xvk_render_buffer_allocation_t XVK_RenderBufferAllocAndLock( uint32_t unit_size, uint32_t count ) {

28
ref_vk/vk_rtx.c
View File

@ -1239,14 +1239,14 @@ qboolean VK_RayInit( void )
//g_rtx.sbt_record_size = ALIGN_UP(vk_core.physical_device.properties_ray_tracing_pipeline.shaderGroupHandleSize, vk_core.physical_device.properties_ray_tracing_pipeline.shaderGroupHandleAlignment);
g_rtx.sbt_record_size = ALIGN_UP(vk_core.physical_device.properties_ray_tracing_pipeline.shaderGroupHandleSize, vk_core.physical_device.properties_ray_tracing_pipeline.shaderGroupBaseAlignment);
if (!createBuffer("ray sbt_buffer", &g_rtx.sbt_buffer, ShaderBindingTable_COUNT * g_rtx.sbt_record_size,
if (!VK_BufferCreate("ray sbt_buffer", &g_rtx.sbt_buffer, ShaderBindingTable_COUNT * g_rtx.sbt_record_size,
VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT | VK_BUFFER_USAGE_SHADER_BINDING_TABLE_BIT_KHR,
VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT | VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT))
{
return false;
}
if (!createBuffer("ray accels_buffer", &g_rtx.accels_buffer, MAX_ACCELS_BUFFER,
if (!VK_BufferCreate("ray accels_buffer", &g_rtx.accels_buffer, MAX_ACCELS_BUFFER,
VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_STORAGE_BIT_KHR | VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT,
VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT
))
@ -1256,7 +1256,7 @@ qboolean VK_RayInit( void )
g_rtx.accels_buffer_addr = getBufferDeviceAddress(g_rtx.accels_buffer.buffer);
g_rtx.accels_buffer_alloc.size = g_rtx.accels_buffer.size;
if (!createBuffer("ray scratch_buffer", &g_rtx.scratch_buffer, MAX_SCRATCH_BUFFER,
if (!VK_BufferCreate("ray scratch_buffer", &g_rtx.scratch_buffer, MAX_SCRATCH_BUFFER,
VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_STORAGE_BIT_KHR | VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT,
VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT
)) {
@ -1264,7 +1264,7 @@ qboolean VK_RayInit( void )
}
g_rtx.scratch_buffer_addr = getBufferDeviceAddress(g_rtx.scratch_buffer.buffer);
if (!createBuffer("ray tlas_geom_buffer", &g_rtx.tlas_geom_buffer, sizeof(VkAccelerationStructureInstanceKHR) * MAX_ACCELS,
if (!VK_BufferCreate("ray tlas_geom_buffer", &g_rtx.tlas_geom_buffer, sizeof(VkAccelerationStructureInstanceKHR) * MAX_ACCELS,
VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT | VK_BUFFER_USAGE_STORAGE_BUFFER_BIT |
VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR,
VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT | VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT)) {
@ -1272,7 +1272,7 @@ qboolean VK_RayInit( void )
return false;
}
if (!createBuffer("ray kusochki_buffer", &g_ray_model_state.kusochki_buffer, sizeof(vk_kusok_data_t) * MAX_KUSOCHKI,
if (!VK_BufferCreate("ray kusochki_buffer", &g_ray_model_state.kusochki_buffer, sizeof(vk_kusok_data_t) * MAX_KUSOCHKI,
VK_BUFFER_USAGE_STORAGE_BUFFER_BIT /* | VK_BUFFER_USAGE_TRANSFER_DST_BIT */,
VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT | VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT)) {
// FIXME complain, handle
@ -1280,14 +1280,14 @@ qboolean VK_RayInit( void )
}
g_ray_model_state.kusochki_alloc.size = MAX_KUSOCHKI;
if (!createBuffer("ray lights_buffer", &g_ray_model_state.lights_buffer, sizeof(struct Lights),
if (!VK_BufferCreate("ray lights_buffer", &g_ray_model_state.lights_buffer, sizeof(struct Lights),
VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT /* | VK_BUFFER_USAGE_TRANSFER_DST_BIT */,
VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT | VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT)) {
// FIXME complain, handle
return false;
}
if (!createBuffer("ray light_grid_buffer", &g_rtx.light_grid_buffer, sizeof(vk_ray_shader_light_grid),
if (!VK_BufferCreate("ray light_grid_buffer", &g_rtx.light_grid_buffer, sizeof(vk_ray_shader_light_grid),
VK_BUFFER_USAGE_STORAGE_BUFFER_BIT /* | VK_BUFFER_USAGE_TRANSFER_DST_BIT */,
VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT | VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT)) {
// FIXME complain, handle
@ -1359,11 +1359,11 @@ void VK_RayShutdown( void ) {
model->as = VK_NULL_HANDLE;
}
destroyBuffer(&g_rtx.scratch_buffer);
destroyBuffer(&g_rtx.accels_buffer);
destroyBuffer(&g_rtx.tlas_geom_buffer);
destroyBuffer(&g_ray_model_state.kusochki_buffer);
destroyBuffer(&g_ray_model_state.lights_buffer);
destroyBuffer(&g_rtx.light_grid_buffer);
destroyBuffer(&g_rtx.sbt_buffer);
VK_BufferDestroy(&g_rtx.scratch_buffer);
VK_BufferDestroy(&g_rtx.accels_buffer);
VK_BufferDestroy(&g_rtx.tlas_geom_buffer);
VK_BufferDestroy(&g_ray_model_state.kusochki_buffer);
VK_BufferDestroy(&g_ray_model_state.lights_buffer);
VK_BufferDestroy(&g_rtx.light_grid_buffer);
VK_BufferDestroy(&g_rtx.sbt_buffer);
}

5
ref_vk/vk_textures.c
View File

@ -2,6 +2,7 @@
#include "vk_common.h"
#include "vk_core.h"
#include "vk_buffer.h"
#include "vk_const.h"
#include "vk_descriptor.h"
#include "vk_mapents.h" // wadlist
@ -587,7 +588,7 @@ static qboolean uploadTexture(vk_texture_t *tex, rgbdata_t *const *const layers,
.depth = 1,
};
memcpy(((uint8_t*)vk_core.staging.mapped) + staging_offset, buf, mip_size);
memcpy(((uint8_t*)g_vk_buffers.staging.mapped) + staging_offset, buf, mip_size);
if ( mip < mipCount - 1 )
{
@ -595,7 +596,7 @@ static qboolean uploadTexture(vk_texture_t *tex, rgbdata_t *const *const layers,
}
// TODO we could do this only once w/ region array
vkCmdCopyBufferToImage(vk_core.cb_tex, vk_core.staging.buffer, tex->vk.image.image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &region);
vkCmdCopyBufferToImage(vk_core.cb_tex, g_vk_buffers.staging.buffer, tex->vk.image.image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &region);
staging_offset += mip_size;
}