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

[WIP] rtx: first build with ray tracing pipeline and black screen

This commit is contained in:
Ivan Avdeev 2021-07-05 13:24:57 -07:00
parent 34359e2f75
commit 364b46ea87
8 changed files with 234 additions and 44 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

110
ref_vk/shaders/ray.rgen Normal file
View File

@ -0,0 +1,110 @@
#version 460 core
#extension GL_EXT_ray_tracing : enable
#extension GL_EXT_shader_16bit_storage : require
#extension GL_EXT_shader_8bit_storage : require
// FIXME shader specialization
//layout(local_size_x = 16, local_size_y = 8, local_size_z = 1) in;
layout(binding = 0, set = 0, rgba8) uniform image2D image;
layout(binding = 1, set = 0) uniform accelerationStructureEXT tlas;
layout(binding = 2, set = 0) uniform UBO {
mat4 inv_proj, inv_view;
// TODO combine
//int num_lights;
//Light lights[];
} ubo;
struct Kusok {
uint index_offset;
uint vertex_offset;
uint triangles;
// Material
uint texture;
float roughness;
};
struct Vertex {
vec3 pos;
vec3 normal;
vec2 gl_tc;
vec2 lm_tc;
};
layout(std430, binding = 3, set = 0) readonly buffer Kusochki { Kusok kusochki[]; };
layout(std430, binding = 4, set = 0) readonly buffer Indices { uint16_t indices[]; };
layout(std430, binding = 5, set = 0) readonly buffer Vertices { Vertex vertices[]; };
// TODO #include, use from here and regular shader
struct Light {
vec4 pos_r;
vec4 color;
};
// FIXME what should this be?
const float dlight_attenuation_const = 20000.;
// TODO specialize in vk_rtx.c
layout (constant_id = 0) const uint max_dlights = 32;
layout(set=0,binding=6) uniform UBODLights {
uint num_lights;
Light lights[max_dlights];
};
struct EmissiveKusok {
uint kusok_index;
vec3 emissive_color;
vec4 tx_row_x, tx_row_y, tx_row_z;
};
layout (constant_id = 1) const uint MAX_EMISSIVE_KUSOCHKI = 256;
layout (set = 0, binding = 7/*, align=4*/) uniform UBOEmissiveKusochki {
uint num_kusochki;
EmissiveKusok kusochki[MAX_EMISSIVE_KUSOCHKI];
} emissive_kusochki;
layout(binding = 8, set = 0, rgba8) uniform readonly image2D previous_frame;
layout (constant_id = 2) const uint MAX_VISIBLE_DLIGHTS = 255;//15;
layout (constant_id = 3) const uint MAX_VISIBLE_SURFACE_LIGHTS = 255;//31;
const uint LIGHT_CLUSTER_SIZE = 2 + MAX_VISIBLE_DLIGHTS + MAX_VISIBLE_SURFACE_LIGHTS;
const uint LIGHT_CLUSTER_NUM_DLIGHTS_OFFSET = 0;
const uint LIGHT_CLUSTER_NUM_EMISSIVE_SURFACES_OFFSET = 1;
const uint LIGHT_CLUSTER_DLIGHTS_DATA_OFFSET = 2;
const uint LIGHT_CLUSTER_EMISSIVE_SURFACES_DATA_OFFSET = 3 + MAX_VISIBLE_DLIGHTS;
struct LightCluster {
uint8_t num_dlights;
uint8_t num_emissive_surfaces;
uint8_t dlights[MAX_VISIBLE_DLIGHTS];
uint8_t emissive_surfaces[MAX_VISIBLE_SURFACE_LIGHTS];
};
// FIMXE specialize
layout (constant_id = 4) const float LIGHT_GRID_CELL_SIZE = 256.;
layout (constant_id = 5) const uint MAX_LIGHT_CLUSTERS = 32768;
const uint HACK_OFFSET = 0;
layout (set = 0, binding = 9, align = 1) readonly buffer UBOLightClusters {
ivec3 grid_min, grid_size;
//uint8_t clusters_data[MAX_LIGHT_CLUSTERS * LIGHT_CLUSTER_SIZE + HACK_OFFSET];
LightCluster clusters[MAX_LIGHT_CLUSTERS];
} light_grid;
layout (constant_id = 6) const uint MAX_TEXTURES = 4096;
layout (set = 0, binding = 10) uniform sampler2D textures[MAX_TEXTURES];
layout (push_constant) uniform PC {
float t;
int bounces;
float prev_frame_blend_factor;
} pc;
void main() {
// vec2 res = imageSize(image);
// vec2 uv = (gl_LaunchIDEXT.xy + .5) / res * 2. - 1.;
//imageStore(image, ivec2(gl_LaunchIDEXT.xy), vec4(vec3(uv.x * uv.y), 1.)); return;
imageStore(image, ivec2(gl_LaunchIDEXT.xy), vec4(1.)); return;
}

17
ref_vk/vk_core.c
View File

@ -130,8 +130,7 @@ static const char* device_extensions[] = {
// Optional: RTX
VK_KHR_ACCELERATION_STRUCTURE_EXTENSION_NAME,
//VK_KHR_RAY_TRACING_PIPELINE_EXTENSION_NAME,
VK_KHR_RAY_QUERY_EXTENSION_NAME,
VK_KHR_RAY_TRACING_PIPELINE_EXTENSION_NAME,
VK_KHR_DEFERRED_HOST_OPERATIONS_EXTENSION_NAME,
// FIXME make this not depend on RTX
@ -388,8 +387,8 @@ static qboolean pickAndCreateDevice( void )
};
VkPhysicalDeviceAccelerationStructureFeaturesKHR accel_feature = {
.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR,
.accelerationStructure = VK_TRUE,
.pNext = &buffer_address_feature,
.accelerationStructure = VK_TRUE,
};
VkPhysicalDevice8BitStorageFeatures eight_bit_feature = {
.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES,
@ -402,12 +401,13 @@ static qboolean pickAndCreateDevice( void )
.pNext = &eight_bit_feature,
.storageBuffer16BitAccess = VK_TRUE,
};
VkPhysicalDeviceRayQueryFeaturesKHR ray_query_feature = {
.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR,
.rayQuery = VK_TRUE,
VkPhysicalDeviceRayTracingPipelineFeaturesKHR ray_tracing_pipeline_feature = {
.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR,
.pNext = &sixteen_bit_feature,
.rayTracingPipeline = VK_TRUE,
// TODO .rayTraversalPrimitiveCulling = VK_TRUE,
};
void *head = &ray_query_feature;
void *head = &ray_tracing_pipeline_feature;
#ifdef USE_AFTERMATH
VkDeviceDiagnosticsConfigCreateInfoNV diag_config_nv = {
.sType = VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV,
@ -448,6 +448,9 @@ static qboolean pickAndCreateDevice( void )
loadDeviceFunctions(device_funcs_rtx, ARRAYSIZE(device_funcs_rtx));
vk_core.physical_device.properties2.pNext = &vk_core.physical_device.properties_accel;
vk_core.physical_device.properties_accel.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR;
vk_core.physical_device.properties_accel.pNext = &vk_core.physical_device.properties_ray_tracing_pipeline;
vk_core.physical_device.properties_ray_tracing_pipeline.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR;
vk_core.physical_device.properties_ray_tracing_pipeline.pNext = NULL;
}
// TODO should we check Vk version first?

4
ref_vk/vk_core.h
View File

@ -42,6 +42,7 @@ typedef struct physical_device_s {
VkPhysicalDeviceProperties properties;
VkPhysicalDeviceProperties2 properties2;
VkPhysicalDeviceAccelerationStructurePropertiesKHR properties_accel;
VkPhysicalDeviceRayTracingPipelinePropertiesKHR properties_ray_tracing_pipeline;
} physical_device_t;
typedef struct vulkan_core_s {
@ -213,6 +214,9 @@ do { \
X(vkCmdBuildAccelerationStructuresKHR) \
X(vkDestroyAccelerationStructureKHR) \
X(vkGetAccelerationStructureDeviceAddressKHR) \
X(vkCmdTraceRaysKHR) \
X(vkCreateRayTracingPipelinesKHR) \
X(vkGetRayTracingShaderGroupHandlesKHR) \
#define X(f) extern PFN_##f f;
DEVICE_FUNCS(X)

16
ref_vk/vk_pipeline.c
View File

@ -6,25 +6,23 @@
#define MAX_STAGES 2
static struct {
VkPipelineCache cache;
} g_pipeline;
VkPipelineCache g_pipeline_cache;
qboolean VK_PipelineInit( void )
{
VkPipelineCacheCreateInfo pcci = {
.sType = VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO,
.initialDataSize = 0,
.pInitialData = NULL,
.sType = VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO,
.initialDataSize = 0,
.pInitialData = NULL,
};
XVK_CHECK(vkCreatePipelineCache(vk_core.device, &pcci, NULL, &g_pipeline.cache));
XVK_CHECK(vkCreatePipelineCache(vk_core.device, &pcci, NULL, &g_pipeline_cache));
return true;
}
void VK_PipelineShutdown( void )
{
vkDestroyPipelineCache(vk_core.device, g_pipeline.cache, NULL);
vkDestroyPipelineCache(vk_core.device, g_pipeline_cache, NULL);
}
VkPipeline VK_PipelineGraphicsCreate(const vk_pipeline_graphics_create_info_t *ci)
@ -135,7 +133,7 @@ VkPipeline VK_PipelineGraphicsCreate(const vk_pipeline_graphics_create_info_t *c
};
}
XVK_CHECK(vkCreateGraphicsPipelines(vk_core.device, g_pipeline.cache, 1, &gpci, NULL, &pipeline));
XVK_CHECK(vkCreateGraphicsPipelines(vk_core.device, g_pipeline_cache, 1, &gpci, NULL, &pipeline));
for (int i = 0; i < ci->num_stages; ++i) {
vkDestroyShaderModule(vk_core.device, stage_create_infos[i].module, NULL);

2
ref_vk/vk_pipeline.h
View File

@ -43,3 +43,5 @@ VkPipeline VK_PipelineComputeCreate(const vk_pipeline_compute_create_info_t *ci)
qboolean VK_PipelineInit( void );
void VK_PipelineShutdown( void );
extern VkPipelineCache g_pipeline_cache;

122
ref_vk/vk_rtx.c
View File

@ -20,6 +20,8 @@
#define MAX_LIGHT_LEAVES 8192
#define SBT_SIZE 1
// TODO settings/realtime modifiable/adaptive
#define FRAME_WIDTH 1280
#define FRAME_HEIGHT 720
@ -70,6 +72,10 @@ static struct {
VkPipeline pipeline;
// Shader binding table buffer
vk_buffer_t sbt_buffer;
uint32_t sbt_record_size;
// Stores AS built data. Lifetime similar to render buffer:
// - some portion lives for entire map lifetime
// - some portion lives only for a single frame (may have several frames in flight)
@ -338,14 +344,53 @@ static void createPipeline( void )
.dataSize = sizeof(spec_data),
.pData = &spec_data,
};
const vk_pipeline_compute_create_info_t ci = {
.layout = g_rtx.descriptors.pipeline_layout,
.shader_filename = "rtx.comp.spv",
.specialization_info = &spec,
const VkPipelineShaderStageCreateInfo shaders[] = {
{
.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
.stage = VK_SHADER_STAGE_RAYGEN_BIT_KHR,
.module = loadShader("ray.rgen.spv"),
.pSpecializationInfo = &spec,
.pName = "main",
},
};
g_rtx.pipeline = VK_PipelineComputeCreate(&ci);
ASSERT(g_rtx.pipeline);
const VkRayTracingShaderGroupCreateInfoKHR shader_groups[SBT_SIZE] = {
{
.sType = VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR,
.type = VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_KHR,
.anyHitShader = VK_SHADER_UNUSED_KHR,
.closestHitShader = VK_SHADER_UNUSED_KHR,
.generalShader = 0, // raygen stage index; FIXME enum
.intersectionShader = VK_SHADER_UNUSED_KHR,
}
};
const VkRayTracingPipelineCreateInfoKHR rtpci = {
.sType = VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_KHR,
//TODO .flags = VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_BIT_KHR ....
.stageCount = ARRAYSIZE(shaders),
.pStages = shaders,
.groupCount = ARRAYSIZE(shader_groups),
.pGroups = shader_groups,
.maxPipelineRayRecursionDepth = 1,
.layout = g_rtx.descriptors.pipeline_layout,
};
XVK_CHECK(vkCreateRayTracingPipelinesKHR(vk_core.device, VK_NULL_HANDLE, g_pipeline_cache, 1, &rtpci, NULL, &g_rtx.pipeline));
{
const uint32_t sbt_handle_size = vk_core.physical_device.properties_ray_tracing_pipeline.shaderGroupHandleSize;
const uint32_t sbt_handles_buffer_size = SBT_SIZE * sbt_handle_size;
uint8_t *sbt_handles = Mem_Malloc(vk_core.pool, sbt_handles_buffer_size);
XVK_CHECK(vkGetRayTracingShaderGroupHandlesKHR(vk_core.device, g_rtx.pipeline, 0, SBT_SIZE, sbt_handles_buffer_size, sbt_handles));
for (int i = 0; i < SBT_SIZE; ++i)
{
uint8_t *sbt_dst = g_rtx.sbt_buffer.mapped;
memcpy(sbt_dst + g_rtx.sbt_record_size * i, sbt_handles + sbt_handle_size, sbt_handle_size);
}
Mem_Free(sbt_handles);
}
}
void VK_RayFrameEnd(const vk_ray_frame_render_args_t* args)
@ -543,23 +588,35 @@ void VK_RayFrameEnd(const vk_ray_frame_render_args_t* args)
.baseArrayLayer = 0,
.layerCount = 1,
}} };
vkCmdPipelineBarrier(cmdbuf, VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_KHR, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, 0,
vkCmdPipelineBarrier(cmdbuf, VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_KHR, VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR, 0,
0, NULL, ARRAYSIZE(bmb), bmb, ARRAYSIZE(image_barrier), image_barrier);
}
if (g_rtx.tlas) {
// 4. dispatch compute
vkCmdBindPipeline(cmdbuf, VK_PIPELINE_BIND_POINT_COMPUTE, g_rtx.pipeline);
// 4. dispatch ray tracing
vkCmdBindPipeline(cmdbuf, VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR, g_rtx.pipeline);
{
vk_rtx_push_constants_t push_constants = {
.t = gpGlobals->realtime,
.bounces = vk_rtx_bounces->value,
.prev_frame_blend_factor = vk_rtx_prev_frame_blend_factor->value,
};
vkCmdPushConstants(cmdbuf, g_rtx.descriptors.pipeline_layout, VK_SHADER_STAGE_COMPUTE_BIT, 0, sizeof(push_constants), &push_constants);
vkCmdPushConstants(cmdbuf, g_rtx.descriptors.pipeline_layout, VK_SHADER_STAGE_RAYGEN_BIT_KHR, 0, sizeof(push_constants), &push_constants);
}
vkCmdBindDescriptorSets(cmdbuf, VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR, g_rtx.descriptors.pipeline_layout, 0, 1, g_rtx.descriptors.desc_sets + 0, 0, NULL);
{
const VkStridedDeviceAddressRegionKHR sbt_raygen = {
.deviceAddress = getBufferDeviceAddress(g_rtx.sbt_buffer.buffer),
.size = vk_core.physical_device.properties_ray_tracing_pipeline.shaderGroupHandleSize,
.stride = vk_core.physical_device.properties_ray_tracing_pipeline.shaderGroupHandleSize,
};
const VkStridedDeviceAddressRegionKHR sbt_miss = { .deviceAddress = 0, };
const VkStridedDeviceAddressRegionKHR sbt_hit = { .deviceAddress = 0, };
const VkStridedDeviceAddressRegionKHR sbt_callable = { .deviceAddress = 0, };
vkCmdTraceRaysKHR(cmdbuf, &sbt_raygen, &sbt_hit, &sbt_miss, &sbt_callable, FRAME_WIDTH, FRAME_HEIGHT, 1 );
}
vkCmdBindDescriptorSets(cmdbuf, VK_PIPELINE_BIND_POINT_COMPUTE, g_rtx.descriptors.pipeline_layout, 0, 1, g_rtx.descriptors.desc_sets + 0, 0, NULL);
vkCmdDispatch(cmdbuf, (FRAME_WIDTH + WG_W - 1) / WG_W, (FRAME_HEIGHT + WG_H - 1) / WG_H, 1);
}
// Blit RTX frame onto swapchain image
@ -598,7 +655,7 @@ void VK_RayFrameEnd(const vk_ray_frame_render_args_t* args)
},
}};
vkCmdPipelineBarrier(args->cmdbuf,
VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT,
VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR,
VK_PIPELINE_STAGE_TRANSFER_BIT,
0, 0, NULL, 0, NULL, ARRAYSIZE(image_barriers), image_barriers);
}
@ -654,84 +711,84 @@ static void createLayouts( void ) {
g_rtx.descriptors.push_constants = (VkPushConstantRange){
.offset = 0,
.size = sizeof(vk_rtx_push_constants_t),
.stageFlags = VK_SHADER_STAGE_COMPUTE_BIT,
.stageFlags = VK_SHADER_STAGE_RAYGEN_BIT_KHR,
};
g_rtx.desc_bindings[RayDescBinding_DestImage] = (VkDescriptorSetLayoutBinding){
.binding = RayDescBinding_DestImage,
.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE,
.descriptorCount = 1,
.stageFlags = VK_SHADER_STAGE_COMPUTE_BIT,
.stageFlags = VK_SHADER_STAGE_RAYGEN_BIT_KHR,
};
g_rtx.desc_bindings[RayDescBinding_TLAS] = (VkDescriptorSetLayoutBinding){
.binding = RayDescBinding_TLAS,
.descriptorType = VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR,
.descriptorCount = 1,
.stageFlags = VK_SHADER_STAGE_COMPUTE_BIT,
.stageFlags = VK_SHADER_STAGE_RAYGEN_BIT_KHR,
};
g_rtx.desc_bindings[RayDescBinding_UBOMatrices] = (VkDescriptorSetLayoutBinding){
.binding = RayDescBinding_UBOMatrices,
.descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
.descriptorCount = 1,
.stageFlags = VK_SHADER_STAGE_COMPUTE_BIT,
.stageFlags = VK_SHADER_STAGE_RAYGEN_BIT_KHR,
};
g_rtx.desc_bindings[RayDescBinding_Kusochki] = (VkDescriptorSetLayoutBinding){
.binding = RayDescBinding_Kusochki,
.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
.descriptorCount = 1,
.stageFlags = VK_SHADER_STAGE_COMPUTE_BIT,
.stageFlags = VK_SHADER_STAGE_RAYGEN_BIT_KHR,
};
g_rtx.desc_bindings[RayDescBinding_Indices] = (VkDescriptorSetLayoutBinding){
.binding = RayDescBinding_Indices,
.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
.descriptorCount = 1,
.stageFlags = VK_SHADER_STAGE_COMPUTE_BIT,
.stageFlags = VK_SHADER_STAGE_RAYGEN_BIT_KHR,
};
g_rtx.desc_bindings[RayDescBinding_Vertices] = (VkDescriptorSetLayoutBinding){
.binding = RayDescBinding_Vertices,
.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
.descriptorCount = 1,
.stageFlags = VK_SHADER_STAGE_COMPUTE_BIT,
.stageFlags = VK_SHADER_STAGE_RAYGEN_BIT_KHR,
};
g_rtx.desc_bindings[RayDescBinding_UBOLights] = (VkDescriptorSetLayoutBinding){
.binding = RayDescBinding_UBOLights,
.descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
.descriptorCount = 1,
.stageFlags = VK_SHADER_STAGE_COMPUTE_BIT,
.stageFlags = VK_SHADER_STAGE_RAYGEN_BIT_KHR,
};
g_rtx.desc_bindings[RayDescBinding_EmissiveKusochki] = (VkDescriptorSetLayoutBinding){
.binding = RayDescBinding_EmissiveKusochki,
.descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
.descriptorCount = 1,
.stageFlags = VK_SHADER_STAGE_COMPUTE_BIT,
.stageFlags = VK_SHADER_STAGE_RAYGEN_BIT_KHR,
};
g_rtx.desc_bindings[RayDescBinding_PrevFrame] = (VkDescriptorSetLayoutBinding){
.binding = RayDescBinding_PrevFrame,
.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE,
.descriptorCount = 1,
.stageFlags = VK_SHADER_STAGE_COMPUTE_BIT,
.stageFlags = VK_SHADER_STAGE_RAYGEN_BIT_KHR,
};
g_rtx.desc_bindings[RayDescBinding_LightClusters] = (VkDescriptorSetLayoutBinding){
.binding = RayDescBinding_LightClusters,
.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
.descriptorCount = 1,
.stageFlags = VK_SHADER_STAGE_COMPUTE_BIT,
.stageFlags = VK_SHADER_STAGE_RAYGEN_BIT_KHR,
};
g_rtx.desc_bindings[RayDescBinding_Textures] = (VkDescriptorSetLayoutBinding){
.binding = RayDescBinding_Textures,
.descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
.descriptorCount = MAX_TEXTURES,
.stageFlags = VK_SHADER_STAGE_COMPUTE_BIT,
.stageFlags = VK_SHADER_STAGE_RAYGEN_BIT_KHR,
.pImmutableSamplers = samplers,
};
@ -753,6 +810,18 @@ qboolean VK_RayInit( void )
{
ASSERT(vk_core.rtx);
// TODO complain and cleanup on failure
//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, SBT_SIZE * 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,
VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_STORAGE_BIT_KHR | VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT,
VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT
@ -835,7 +904,7 @@ qboolean VK_RayInit( void )
};
XVK_CHECK(vkBeginCommandBuffer(vk_core.cb, &beginfo));
vkCmdPipelineBarrier(vk_core.cb, VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_KHR, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, 0,
vkCmdPipelineBarrier(vk_core.cb, VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_KHR, VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR, 0,
0, NULL, 0, NULL, ARRAYSIZE(image_barriers), image_barriers);
vkCmdClearColorImage(vk_core.cb, frame_src->image, VK_IMAGE_LAYOUT_GENERAL, &clear_value, 1, &image_barriers->subresourceRange);
XVK_CHECK(vkEndCommandBuffer(vk_core.cb));
@ -885,4 +954,5 @@ void VK_RayShutdown( void )
destroyBuffer(&g_ray_model_state.kusochki_buffer);
destroyBuffer(&g_ray_model_state.emissive_kusochki_buffer);
destroyBuffer(&g_rtx.light_grid_buffer);
destroyBuffer(&g_rtx.sbt_buffer);
}

5
ref_vk/wscript
View File

@ -62,6 +62,9 @@ def configure(conf):
# TODO if debug
conf.env.GLSLCFLAGS += ['-g']
# TODO for rtx shaders only (rgen, ...)
conf.env.GLSLCFLAGS += ['--target-env=vulkan1.2']
def build(bld):
if not bld.env.VK:
return
@ -71,7 +74,7 @@ def build(bld):
libpath = []
source = bld.path.ant_glob(['*.c'])
glsl_source = bld.path.ant_glob(['shaders/*.vert', 'shaders/*.frag', 'shaders/*.comp'])
glsl_source = bld.path.ant_glob(['shaders/*.vert', 'shaders/*.frag', 'shaders/*.comp', 'shaders/*.rgen'])
includes = ['.',
'../engine',

2
scripts/waifulib/glslc.py
View File

@ -35,7 +35,7 @@ class glsl(Task.Task):
def keyword(self):
return 'Compiling shader'
@TaskGen.extension('.vert', '.frag', '.comp')
@TaskGen.extension('.vert', '.frag', '.comp', '.rgen')
def process_glsl_source(self, src):
# see ccroot.apply_incpaths
lst = self.to_incnodes(self.to_list(getattr(self, 'includes', [])) + self.env.GLSLCINCLUDES)