/* vulkan_lighting.c Vulkan lighting pass pipeline Copyright (C) 2021 Bill Currie Author: Bill Currie Date: 2021/2/23 This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to: Free Software Foundation, Inc. 59 Temple Place - Suite 330 Boston, MA 02111-1307, USA */ #ifdef HAVE_CONFIG_H # include "config.h" #endif #ifdef HAVE_STRING_H # include #endif #ifdef HAVE_STRINGS_H # include #endif #include #include "qfalloca.h" #include "QF/dstring.h" #include "QF/plist.h" #include "QF/progs.h" #include "QF/script.h" #include "QF/set.h" #include "QF/sys.h" #include "QF/va.h" #include "QF/Vulkan/qf_lighting.h" #include "QF/Vulkan/qf_texture.h" #include "QF/Vulkan/barrier.h" #include "QF/Vulkan/buffer.h" #include "QF/Vulkan/debug.h" #include "QF/Vulkan/descriptor.h" #include "QF/Vulkan/device.h" #include "QF/Vulkan/image.h" #include "QF/Vulkan/instance.h" #include "QF/Vulkan/projection.h" #include "QF/Vulkan/renderpass.h" #include "QF/Vulkan/staging.h" #include "compat.h" #include "r_internal.h" #include "vid_vulkan.h" static vec4f_t ref_direction = { 0, 0, 1, 0 }; static void expand_pvs (set_t *pvs, model_t *model) { set_t base_pvs = SET_STATIC_INIT (model->brush.visleafs, alloca); set_assign (&base_pvs, pvs); for (unsigned i = 0; i < model->brush.visleafs; i++) { if (set_is_member (&base_pvs, i)) { Mod_LeafPVS_mix (model->brush.leafs + i + 1, model, 0, pvs); } } } static void find_visible_lights (vulkan_ctx_t *ctx) { //qfv_device_t *device = ctx->device; //qfv_devfuncs_t *dfunc = device->funcs; lightingctx_t *lctx = ctx->lighting_context; lightingframe_t *lframe = &lctx->frames.a[ctx->curFrame]; mleaf_t *leaf = r_viewleaf; model_t *model = r_worldentity.renderer.model; if (!leaf || !model) { return; } if (leaf != lframe->leaf) { //double start = Sys_DoubleTime (); int flags = 0; if (leaf == model->brush.leafs) { set_everything (lframe->pvs); } else { Mod_LeafPVS_set (leaf, model, 0, lframe->pvs); expand_pvs (lframe->pvs, model); } for (unsigned i = 0; i < model->brush.visleafs; i++) { if (set_is_member (lframe->pvs, i)) { flags |= model->brush.leaf_flags[i + 1]; } } lframe->leaf = leaf; //double end = Sys_DoubleTime (); //Sys_Printf ("find_visible_lights: %.5gus\n", (end - start) * 1e6); int visible = 0; memset (lframe->lightvis.a, 0, lframe->lightvis.size * sizeof (byte)); for (size_t i = 0; i < lctx->lightleafs.size; i++) { int l = lctx->lightleafs.a[i]; if ((l == -1 && (flags & SURF_DRAWSKY)) || set_is_member (lframe->pvs, l)) { lframe->lightvis.a[i] = 1; visible++; } } //Sys_Printf ("find_visible_lights: %d / %zd visible\n", visible, // lframe->lightvis.size); } } static void update_lights (vulkan_ctx_t *ctx) { qfv_device_t *device = ctx->device; qfv_devfuncs_t *dfunc = device->funcs; lightingctx_t *lctx = ctx->lighting_context; lightingframe_t *lframe = &lctx->frames.a[ctx->curFrame]; find_visible_lights (ctx); dlight_t *lights[MaxLights]; qfv_packet_t *packet = QFV_PacketAcquire (ctx->staging); qfv_light_buffer_t *light_data = QFV_PacketExtend (packet, sizeof (*light_data)); for (int i = 0; i < NumStyles; i++) { light_data->intensity[i] = d_lightstylevalue[i] / 65536.0; } // dynamic lights seem a tad faint, so 16x map lights light_data->intensity[64] = 1 / 16.0; light_data->intensity[65] = 1 / 16.0; light_data->intensity[66] = 1 / 16.0; light_data->intensity[67] = 1 / 16.0; light_data->distFactor1 = 1 / 128.0; light_data->distFactor2 = 1 / 16384.0; light_data->lightCount = 0; R_FindNearLights (r_origin, MaxLights - 1, lights); for (int i = 0; i < MaxLights - 1; i++) { if (!lights[i]) { break; } light_data->lightCount++; VectorCopy (lights[i]->color, light_data->lights[i].color); VectorCopy (lights[i]->origin, light_data->lights[i].position); light_data->lights[i].light = lights[i]->radius; light_data->lights[i].data = 64; // default dynamic light VectorZero (light_data->lights[i].direction); light_data->lights[i].cone = 1; } for (size_t i = 0; (i < lframe->lightvis.size && light_data->lightCount < MaxLights); i++) { if (lframe->lightvis.a[i]) { light_data->lights[light_data->lightCount++] = lctx->lights.a[i]; } } qfv_bufferbarrier_t bb = bufferBarriers[qfv_BB_Unknown_to_TransferWrite]; bb.barrier.buffer = lframe->light_buffer; bb.barrier.size = sizeof (qfv_light_buffer_t); dfunc->vkCmdPipelineBarrier (packet->cmd, bb.srcStages, bb.dstStages, 0, 0, 0, 1, &bb.barrier, 0, 0); VkBufferCopy copy_region[] = { { packet->offset, 0, sizeof (qfv_light_buffer_t) }, }; dfunc->vkCmdCopyBuffer (packet->cmd, ctx->staging->buffer, lframe->light_buffer, 1, ©_region[0]); bb = bufferBarriers[qfv_BB_TransferWrite_to_UniformRead]; bb.barrier.buffer = lframe->light_buffer; bb.barrier.size = sizeof (qfv_light_buffer_t); dfunc->vkCmdPipelineBarrier (packet->cmd, bb.srcStages, bb.dstStages, 0, 0, 0, 1, &bb.barrier, 0, 0); QFV_PacketSubmit (packet); } void Vulkan_Lighting_Draw (qfv_renderframe_t *rFrame) { vulkan_ctx_t *ctx = rFrame->vulkan_ctx; qfv_device_t *device = ctx->device; qfv_devfuncs_t *dfunc = device->funcs; qfv_renderpass_t *renderpass = rFrame->renderpass; update_lights (ctx); lightingctx_t *lctx = ctx->lighting_context; __auto_type cframe = &ctx->frames.a[ctx->curFrame]; lightingframe_t *lframe = &lctx->frames.a[ctx->curFrame]; VkCommandBuffer cmd = lframe->cmd; DARRAY_APPEND (&rFrame->subpassCmdSets[QFV_passLighting], cmd); dfunc->vkResetCommandBuffer (cmd, 0); VkCommandBufferInheritanceInfo inherit = { VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO, 0, renderpass->renderpass, QFV_passLighting, cframe->framebuffer, 0, 0, 0, }; VkCommandBufferBeginInfo beginInfo = { VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, 0, VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT | VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT, &inherit, }; dfunc->vkBeginCommandBuffer (cmd, &beginInfo); QFV_duCmdBeginLabel (device, cmd, "lighting", { 0.6, 0.5, 0.6, 1}); dfunc->vkCmdBindPipeline (cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, lctx->pipeline); lframe->bufferInfo[0].buffer = lframe->light_buffer; lframe->attachInfo[0].imageView = renderpass->attachment_views->a[QFV_attachDepth]; lframe->attachInfo[1].imageView = renderpass->attachment_views->a[QFV_attachColor]; lframe->attachInfo[2].imageView = renderpass->attachment_views->a[QFV_attachEmission]; lframe->attachInfo[3].imageView = renderpass->attachment_views->a[QFV_attachNormal]; lframe->attachInfo[4].imageView = renderpass->attachment_views->a[QFV_attachPosition]; dfunc->vkUpdateDescriptorSets (device->dev, LIGHTING_DESCRIPTORS, lframe->descriptors, 0, 0); VkDescriptorSet sets[] = { lframe->attachWrite[0].dstSet, lframe->bufferWrite[0].dstSet, lframe->shadowWrite.dstSet, }; dfunc->vkCmdBindDescriptorSets (cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, lctx->layout, 0, 3, sets, 0, 0); dfunc->vkCmdSetViewport (cmd, 0, 1, &ctx->viewport); dfunc->vkCmdSetScissor (cmd, 0, 1, &ctx->scissor); VkDeviceSize offset = 0; dfunc->vkCmdBindVertexBuffers (cmd, 0, 1, &ctx->quad_buffer, &offset); dfunc->vkCmdDraw (cmd, 4, 1, 0, 0); QFV_duCmdEndLabel (device, cmd); dfunc->vkEndCommandBuffer (cmd); } static VkDescriptorBufferInfo base_buffer_info = { 0, 0, VK_WHOLE_SIZE }; static VkDescriptorImageInfo base_image_info = { 0, 0, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL }; static VkWriteDescriptorSet base_buffer_write = { VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, 0, 0, 0, 0, 1, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 0, 0, 0 }; static VkWriteDescriptorSet base_attachment_write = { VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, 0, 0, 0, 0, 1, VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, 0, 0, 0 }; static VkWriteDescriptorSet base_image_write = { VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, 0, 0, 0, 0, 1, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 0, 0, 0 }; void Vulkan_Lighting_Init (vulkan_ctx_t *ctx) { qfv_device_t *device = ctx->device; qfv_devfuncs_t *dfunc = device->funcs; lightingctx_t *lctx = calloc (1, sizeof (lightingctx_t)); ctx->lighting_context = lctx; DARRAY_INIT (&lctx->lights, 16); DARRAY_INIT (&lctx->lightleafs, 16); DARRAY_INIT (&lctx->lightmats, 16); DARRAY_INIT (&lctx->lightlayers, 16); DARRAY_INIT (&lctx->lightimages, 16); DARRAY_INIT (&lctx->lightviews, 16); size_t frames = ctx->frames.size; DARRAY_INIT (&lctx->frames, frames); DARRAY_RESIZE (&lctx->frames, frames); lctx->frames.grow = 0; lctx->pipeline = Vulkan_CreatePipeline (ctx, "lighting"); lctx->layout = Vulkan_CreatePipelineLayout (ctx, "lighting_layout"); lctx->sampler = Vulkan_CreateSampler (ctx, "shadow_sampler"); __auto_type lbuffers = QFV_AllocBufferSet (frames, alloca); for (size_t i = 0; i < frames; i++) { lbuffers->a[i] = QFV_CreateBuffer (device, sizeof (qfv_light_buffer_t), VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT); QFV_duSetObjectName (device, VK_OBJECT_TYPE_BUFFER, lbuffers->a[i], va (ctx->va_ctx, "buffer:lighting:%zd", i)); } VkMemoryRequirements requirements; dfunc->vkGetBufferMemoryRequirements (device->dev, lbuffers->a[0], &requirements); lctx->light_memory = QFV_AllocBufferMemory (device, lbuffers->a[0], VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, QFV_NextOffset (0, frames, &requirements), 0); QFV_duSetObjectName (device, VK_OBJECT_TYPE_DEVICE_MEMORY, lctx->light_memory, "memory:lighting"); __auto_type cmdSet = QFV_AllocCommandBufferSet (1, alloca); __auto_type attach = QFV_AllocDescriptorSetLayoutSet (frames, alloca); __auto_type lights = QFV_AllocDescriptorSetLayoutSet (frames, alloca); __auto_type shadow = QFV_AllocDescriptorSetLayoutSet (frames, alloca); for (size_t i = 0; i < frames; i++) { attach->a[i] = Vulkan_CreateDescriptorSetLayout (ctx, "lighting_attach"); lights->a[i] = Vulkan_CreateDescriptorSetLayout (ctx, "lighting_lights"); shadow->a[i] = Vulkan_CreateDescriptorSetLayout (ctx, "lighting_shadow"); } __auto_type attach_pool = Vulkan_CreateDescriptorPool (ctx, "lighting_attach_pool"); __auto_type lights_pool = Vulkan_CreateDescriptorPool (ctx, "lighting_lights_pool"); __auto_type shadow_pool = Vulkan_CreateDescriptorPool (ctx, "lighting_shadow_pool"); __auto_type attach_set = QFV_AllocateDescriptorSet (device, attach_pool, attach); __auto_type lights_set = QFV_AllocateDescriptorSet (device, lights_pool, lights); __auto_type shadow_set = QFV_AllocateDescriptorSet (device, shadow_pool, shadow); VkDeviceSize light_offset = 0; for (size_t i = 0; i < frames; i++) { __auto_type lframe = &lctx->frames.a[i]; QFV_duSetObjectName (device, VK_OBJECT_TYPE_DESCRIPTOR_SET, attach_set->a[i], va (ctx->va_ctx, "lighting:attach_set:%zd", i)); QFV_duSetObjectName (device, VK_OBJECT_TYPE_DESCRIPTOR_SET, lights_set->a[i], va (ctx->va_ctx, "lighting:lights_set:%zd", i)); QFV_duSetObjectName (device, VK_OBJECT_TYPE_DESCRIPTOR_SET, shadow_set->a[i], va (ctx->va_ctx, "lighting:shadow_set:%zd", i)); DARRAY_INIT (&lframe->lightvis, 16); lframe->pvs = 0; lframe->leaf = 0; QFV_AllocateCommandBuffers (device, ctx->cmdpool, 1, cmdSet); lframe->cmd = cmdSet->a[0]; lframe->light_buffer = lbuffers->a[i]; QFV_BindBufferMemory (device, lbuffers->a[i], lctx->light_memory, light_offset); light_offset = QFV_NextOffset (light_offset, 1, &requirements); QFV_duSetObjectName (device, VK_OBJECT_TYPE_COMMAND_BUFFER, lframe->cmd, "cmd:lighting"); for (int j = 0; j < LIGHTING_BUFFER_INFOS; j++) { lframe->bufferInfo[j] = base_buffer_info; lframe->bufferWrite[j] = base_buffer_write; lframe->bufferWrite[j].dstSet = lights_set->a[i]; lframe->bufferWrite[j].dstBinding = j; lframe->bufferWrite[j].pBufferInfo = &lframe->bufferInfo[j]; } for (int j = 0; j < LIGHTING_ATTACH_INFOS; j++) { lframe->attachInfo[j] = base_image_info; lframe->attachInfo[j].sampler = 0; lframe->attachWrite[j] = base_attachment_write; lframe->attachWrite[j].dstSet = attach_set->a[i]; lframe->attachWrite[j].dstBinding = j; lframe->attachWrite[j].pImageInfo = &lframe->attachInfo[j]; } for (int j = 0; j < LIGHTING_SHADOW_INFOS; j++) { lframe->shadowInfo[j] = base_image_info; lframe->shadowInfo[j].sampler = lctx->sampler; lframe->shadowInfo[j].imageView = ctx->default_black->view; } lframe->shadowWrite = base_image_write; lframe->shadowWrite.dstSet = shadow_set->a[i]; lframe->shadowWrite.dstBinding = 0; lframe->shadowWrite.descriptorCount = MaxLights; lframe->shadowWrite.pImageInfo = lframe->shadowInfo; } free (attach_set); free (lights_set); } static void clear_shadows (vulkan_ctx_t *ctx) { qfv_device_t *device = ctx->device; qfv_devfuncs_t *dfunc = device->funcs; lightingctx_t *lctx = ctx->lighting_context; if (lctx->shadow_memory) { dfunc->vkFreeMemory (device->dev, lctx->shadow_memory, 0); } for (size_t i = 0; i < lctx->lightviews.size; i++) { dfunc->vkDestroyImageView (device->dev, lctx->lightviews.a[i], 0); } for (size_t i = 0; i < lctx->lightimages.size; i++) { dfunc->vkDestroyImage (device->dev, lctx->lightimages.a[i], 0); } lctx->lightimages.size = 0; lctx->lightviews.size = 0; } void Vulkan_Lighting_Shutdown (vulkan_ctx_t *ctx) { qfv_device_t *device = ctx->device; qfv_devfuncs_t *dfunc = device->funcs; lightingctx_t *lctx = ctx->lighting_context; clear_shadows (ctx); for (size_t i = 0; i < lctx->frames.size; i++) { lightingframe_t *lframe = &lctx->frames.a[i]; dfunc->vkDestroyBuffer (device->dev, lframe->light_buffer, 0); DARRAY_CLEAR (&lframe->lightvis); } dfunc->vkFreeMemory (device->dev, lctx->light_memory, 0); dfunc->vkDestroyPipeline (device->dev, lctx->pipeline, 0); DARRAY_CLEAR (&lctx->lights); DARRAY_CLEAR (&lctx->lightleafs); DARRAY_CLEAR (&lctx->lightmats); DARRAY_CLEAR (&lctx->lightimages); DARRAY_CLEAR (&lctx->lightlayers); DARRAY_CLEAR (&lctx->lightviews); free (lctx->frames.a); free (lctx); } static void dump_light (qfv_light_t *light, int leaf, mat4f_t mat) { Sys_MaskPrintf (SYS_vulkan, "[%g, %g, %g] %d %d %d, " "[%g %g %g] %g, [%g %g %g] %g, %d\n", VectorExpand (light->color), (light->data & 0x07f), (light->data & 0x380) >> 7, (light->data & 0xc00) >> 10, VectorExpand (light->position), light->light, VectorExpand (light->direction), light->cone, leaf); Sys_MaskPrintf (SYS_vulkan, " " VEC4F_FMT "\n", MAT4_ROW (mat, 0)); Sys_MaskPrintf (SYS_vulkan, " " VEC4F_FMT "\n", MAT4_ROW (mat, 1)); Sys_MaskPrintf (SYS_vulkan, " " VEC4F_FMT "\n", MAT4_ROW (mat, 2)); Sys_MaskPrintf (SYS_vulkan, " " VEC4F_FMT "\n", MAT4_ROW (mat, 3)); } static float parse_float (const char *str, float defval) { float val = defval; if (str) { char *end; val = strtof (str, &end); if (end == str) { val = defval; } } return val; } static void parse_vector (const char *str, vec_t *val) { if (str) { int num = sscanf (str, "%f %f %f", VectorExpandAddr (val)); while (num < 3) { val[num++] = 0; } } } static float ecos (float ang) { if (ang == 90 || ang == -90) { return 0; } if (ang == 180 || ang == -180) { return -1; } if (ang == 0 || ang == 360) { return 1; } return cos (ang * M_PI / 180); } static float esin (float ang) { if (ang == 90) { return 1; } if (ang == -90) { return -1; } if (ang == 180 || ang == -180) { return 0; } if (ang == 0 || ang == 360) { return 0; } return sin (ang * M_PI / 180); } static void sun_vector (const vec_t *ang, vec_t *vec) { // ang is yaw, pitch (maybe roll, but ignored vec[0] = ecos (ang[1]) * ecos (ang[0]); vec[1] = ecos (ang[1]) * esin (ang[0]); vec[2] = esin (ang[1]); } static void parse_sun (lightingctx_t *lctx, plitem_t *entity, model_t *model) { qfv_light_t light = {}; float sunlight; //float sunlight2; vec3_t sunangle = { 0, -90, 0 }; set_expand (lctx->sun_pvs, model->brush.visleafs); set_empty (lctx->sun_pvs); sunlight = parse_float (PL_String (PL_ObjectForKey (entity, "_sunlight")), 0); //sunlight2 = parse_float (PL_String (PL_ObjectForKey (entity, // "_sunlight2")), 0); parse_vector (PL_String (PL_ObjectForKey (entity, "_sun_mangle")), sunangle); if (sunlight <= 0) { return; } VectorSet (1, 1, 1, light.color); light.data = LM_INFINITE | ST_CASCADE; light.light = sunlight; sun_vector (sunangle, light.direction); light.cone = 1; DARRAY_APPEND (&lctx->lights, light); DARRAY_APPEND (&lctx->lightleafs, -1); // Any leaf with sky surfaces can potentially see the sun, thus put // the sun "in" every leaf with a sky surface // however, skip leaf 0 as it is the exterior solid leaf for (unsigned l = 1; l < model->brush.modleafs; l++) { if (model->brush.leaf_flags[l] & SURF_DRAWSKY) { set_add (lctx->sun_pvs, l - 1); //pvs is 1-based } } // any leaf visible from a leaf with a sky surface (and thus the sun) // can receive shadows from the sun expand_pvs (lctx->sun_pvs, model); } static void parse_light (qfv_light_t *light, const plitem_t *entity, const plitem_t *targets) { const char *str; int model = 0; /*Sys_Printf ("{\n"); for (int i = PL_D_NumKeys (entity); i-- > 0; ) { const char *field = PL_KeyAtIndex (entity, i); const char *value = PL_String (PL_ObjectForKey (entity, field)); Sys_Printf ("\t%s = %s\n", field, value); } Sys_Printf ("}\n");*/ light->cone = 1; light->data = 0; light->light = 300; VectorSet (1, 1, 1, light->color); if ((str = PL_String (PL_ObjectForKey (entity, "origin")))) { sscanf (str, "%f %f %f", VectorExpandAddr (light->position)); } if ((str = PL_String (PL_ObjectForKey (entity, "target")))) { vec3_t position = {}; plitem_t *target = PL_ObjectForKey (targets, str); if (target) { if ((str = PL_String (PL_ObjectForKey (target, "origin")))) { sscanf (str, "%f %f %f", VectorExpandAddr (position)); } VectorSubtract (position, light->position, light->direction); VectorNormalize (light->direction); } float angle = 40; if ((str = PL_String (PL_ObjectForKey (entity, "angle")))) { angle = atof (str); } light->cone = -cos (angle * M_PI / 360); // half angle } if ((str = PL_String (PL_ObjectForKey (entity, "light_lev"))) || (str = PL_String (PL_ObjectForKey (entity, "_light")))) { light->light = atof (str); } if ((str = PL_String (PL_ObjectForKey (entity, "style")))) { light->data = atoi (str) & 0x3f; } if ((str = PL_String (PL_ObjectForKey (entity, "delay")))) { model = (atoi (str) & 0x7) << 7; if (model == LM_INVERSE2) { model = LM_INVERSE3; //FIXME for marcher (need a map) } light->data |= model; } if ((str = PL_String (PL_ObjectForKey (entity, "color"))) || (str = PL_String (PL_ObjectForKey (entity, "_color")))) { sscanf (str, "%f %f %f", VectorExpandAddr (light->color)); VectorScale (light->color, 1/255.0, light->color); } if (model == LM_INFINITE) { light->data |= ST_CASCADE; } else if (model != LM_AMBIENT) { if (light->cone > -0.5) { light->data |= ST_CUBE; } else { light->data |= ST_PLANE; } } } static void create_light_matrices (lightingctx_t *lctx) { DARRAY_RESIZE (&lctx->lightmats, lctx->lights.size); for (size_t i = 0; i < lctx->lights.size; i++) { qfv_light_t *light = &lctx->lights.a[i]; mat4f_t view; mat4f_t proj; switch (light->data & ShadowMask) { default: case ST_NONE: case ST_CUBE: mat4fidentity (view); break; case ST_CASCADE: case ST_PLANE: //FIXME will fail for -ref_direction mat4fquat (view, qrotf (loadvec3f (light->direction), ref_direction)); break; } VectorNegate (light->position, view[3]); switch (light->data & ShadowMask) { case ST_NONE: mat4fidentity (proj); break; case ST_CUBE: QFV_PerspectiveTan (proj, 1, 1); break; case ST_CASCADE: // dependent on view fustrum and cascade level mat4fidentity (proj); break; case ST_PLANE: QFV_PerspectiveCos (proj, light->cone, 1); break; } mmulf (lctx->lightmats.a[i], proj, view); } } static int light_compare (const void *_l2, const void *_l1) { const qfv_light_t *l1 = _l1; const qfv_light_t *l2 = _l2; if (l1->light == l2->light) { return (l1->data & ShadowMask) - (l2->data & ShadowMask); } return l1->light - l2->light; } static VkImage create_map (int size, int layers, int cube, vulkan_ctx_t *ctx) { qfv_device_t *device = ctx->device; qfv_devfuncs_t *dfunc = device->funcs; if (layers < 6) { cube = 0; } VkImageCreateInfo createInfo = { VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, 0, cube ? VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT : 0, VK_IMAGE_TYPE_2D, VK_FORMAT_X8_D24_UNORM_PACK32, { size, size, 1 }, 1, layers, VK_SAMPLE_COUNT_1_BIT, VK_IMAGE_TILING_OPTIMAL, VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT, VK_SHARING_MODE_EXCLUSIVE, 0, 0, VK_IMAGE_LAYOUT_UNDEFINED, }; VkImage image; dfunc->vkCreateImage (device->dev, &createInfo, 0, &image); QFV_duSetObjectName (device, VK_OBJECT_TYPE_IMAGE, image, va (ctx->va_ctx, "image:shadowmap:%d:%d", size, layers)); return image; } static VkImageView create_view (VkImage image, int baseLayer, int data, int id, vulkan_ctx_t *ctx) { qfv_device_t *device = ctx->device; qfv_devfuncs_t *dfunc = device->funcs; int layers = 0; VkImageViewType type = 0; const char *viewtype = 0; switch (data & ShadowMask) { case ST_NONE: return 0; case ST_PLANE: layers = 1; type = VK_IMAGE_VIEW_TYPE_2D; viewtype = "plane"; break; case ST_CASCADE: layers = 4; type = VK_IMAGE_VIEW_TYPE_2D_ARRAY; viewtype = "cascade"; break; case ST_CUBE: layers = 6; type = VK_IMAGE_VIEW_TYPE_CUBE; viewtype = "cube"; break; } VkImageViewCreateInfo createInfo = { VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, 0, 0, image, type, VK_FORMAT_X8_D24_UNORM_PACK32, { VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY, }, { VK_IMAGE_ASPECT_DEPTH_BIT, 0, 1, baseLayer, layers } }; VkImageView view; dfunc->vkCreateImageView (device->dev, &createInfo, 0, &view); QFV_duSetObjectName (device, VK_OBJECT_TYPE_IMAGE_VIEW, view, va (ctx->va_ctx, "iview:shadowmap:%s:%d", viewtype, id)); (void) viewtype;//silence unused warning when vulkan debug disabled return view; } static void build_shadow_maps (lightingctx_t *lctx, vulkan_ctx_t *ctx) { qfv_device_t *device = ctx->device; qfv_devfuncs_t *dfunc = device->funcs; qfv_physdev_t *physDev = device->physDev; int maxLayers = physDev->properties.limits.maxImageArrayLayers; qfv_light_t *lights = lctx->lights.a; int numLights = lctx->lights.size; int size = -1; int numLayers = 0; int totalLayers = 0; int *imageMap = alloca (numLights * sizeof (int)); size_t memsize = 0; DARRAY_RESIZE (&lctx->lightlayers, numLights); qsort (lights, numLights, sizeof (qfv_light_t), light_compare); for (int i = 0; i < numLights; i++) { int shadow = lights[i].data & ShadowMask; int layers = 1; if (shadow == ST_CASCADE || shadow == ST_NONE) { // cascade shadows will be handled separately, and "none" has no // shadow map at all imageMap[i] = -1; continue; } if (shadow == ST_CUBE) { layers = 6; } if (size != (int) lights[i].light || numLayers + layers > maxLayers) { if (numLayers) { VkImage shadow_map = create_map (size, numLayers, 1, ctx); DARRAY_APPEND (&lctx->lightimages, shadow_map); numLayers = 0; } size = lights[i].light; } imageMap[i] = lctx->lightimages.size; lctx->lightlayers.a[i] = numLayers; numLayers += layers; totalLayers += layers; } if (numLayers) { VkImage shadow_map = create_map (size, numLayers, 1, ctx); DARRAY_APPEND (&lctx->lightimages, shadow_map); } numLayers = 0; size = 1024; for (int i = 0; i < numLights; i++) { int shadow = lights[i].data & ShadowMask; int layers = 4; if (shadow != ST_CASCADE) { continue; } if (numLayers + layers > maxLayers) { VkImage shadow_map = create_map (size, numLayers, 0, ctx); DARRAY_APPEND (&lctx->lightimages, shadow_map); numLayers = 0; } imageMap[i] = lctx->lightimages.size; lctx->lightlayers.a[i] = numLayers; numLayers += layers; totalLayers += layers; } if (numLayers) { VkImage shadow_map = create_map (size, numLayers, 0, ctx); DARRAY_APPEND (&lctx->lightimages, shadow_map); } for (size_t i = 0; i < lctx->lightimages.size; i++) { memsize += QFV_GetImageSize (device, lctx->lightimages.a[i]); } lctx->shadow_memory = QFV_AllocImageMemory (device, lctx->lightimages.a[0], VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, memsize, 0); QFV_duSetObjectName (device, VK_OBJECT_TYPE_DEVICE_MEMORY, lctx->shadow_memory, "memory:shadowmap"); size_t offset = 0; for (size_t i = 0; i < lctx->lightimages.size; i++) { dfunc->vkBindImageMemory (device->dev, lctx->lightimages.a[i], lctx->shadow_memory, offset); offset += QFV_GetImageSize (device, lctx->lightimages.a[i]); } DARRAY_RESIZE (&lctx->lightviews, numLights); for (int i = 0; i < numLights; i++) { if (imageMap[i] == -1) { lctx->lightviews.a[i] = 0; continue; } lctx->lightviews.a[i] = create_view (lctx->lightimages.a[imageMap[i]], lctx->lightlayers.a[i], lctx->lights.a[i].data, i, ctx); } Sys_MaskPrintf (SYS_vulkan, "shadow maps: %d layers in %zd images: %zd\n", totalLayers, lctx->lightimages.size, memsize); } static void locate_lights (model_t *model, lightingctx_t *lctx) { qfv_light_t *lights = lctx->lights.a; DARRAY_RESIZE (&lctx->lightleafs, lctx->lights.size); for (size_t i = 0; i < lctx->lights.size; i++) { mleaf_t *leaf = Mod_PointInLeaf (&lights[i].position[0], model); lctx->lightleafs.a[i] = leaf - model->brush.leafs - 1; } } void Vulkan_LoadLights (model_t *model, const char *entity_data, vulkan_ctx_t *ctx) { lightingctx_t *lctx = ctx->lighting_context; plitem_t *entities = 0; lctx->lights.size = 0; lctx->lightleafs.size = 0; lctx->lightmats.size = 0; if (lctx->sun_pvs) { set_delete (lctx->sun_pvs); } lctx->sun_pvs = set_new_size (model->brush.visleafs); for (size_t i = 0; i < ctx->frames.size; i++) { __auto_type lframe = &lctx->frames.a[i]; if (lframe->pvs) { set_delete (lframe->pvs); } lframe->pvs = set_new_size (model->brush.visleafs); } clear_shadows (ctx); script_t *script = Script_New (); Script_Start (script, "ent data", entity_data); if (Script_GetToken (script, 1)) { if (strequal (script->token->str, "(")) { // new style (plist) entity data entities = PL_GetPropertyList (entity_data, &ctx->hashlinks); } else { // old style entity data Script_UngetToken (script); // FIXME ED_ConvertToPlist aborts if an error is encountered. entities = ED_ConvertToPlist (script, 0, &ctx->hashlinks); } } Script_Delete (script); if (entities) { plitem_t *targets = PL_NewDictionary (&ctx->hashlinks); // find all the targets so spotlights can be aimed for (int i = 1; i < PL_A_NumObjects (entities); i++) { plitem_t *entity = PL_ObjectAtIndex (entities, i); const char *targetname = PL_String (PL_ObjectForKey (entity, "targetname")); if (targetname && !PL_ObjectForKey (targets, targetname)) { PL_D_AddObject (targets, targetname, entity); } } for (int i = 0; i < PL_A_NumObjects (entities); i++) { plitem_t *entity = PL_ObjectAtIndex (entities, i); const char *classname = PL_String (PL_ObjectForKey (entity, "classname")); if (!classname) { continue; } if (strequal (classname, "worldspawn")) { // parse_sun can add many lights parse_sun (lctx, entity, model); } else if (strnequal (classname, "light", 5)) { qfv_light_t light = {}; parse_light (&light, entity, targets); // some lights have 0 output, so drop them if (light.light) { DARRAY_APPEND (&lctx->lights, light); } } } for (size_t i = 0; i < ctx->frames.size; i++) { lightingframe_t *lframe = &lctx->frames.a[i]; DARRAY_RESIZE (&lframe->lightvis, lctx->lights.size); } // targets does not own the objects, so need to remove them before // freeing targets for (int i = PL_D_NumKeys (targets); i-- > 0; ) { PL_RemoveObjectForKey (targets, PL_KeyAtIndex (targets, i)); } PL_Free (targets); PL_Free (entities); } Sys_MaskPrintf (SYS_vulkan, "loaded %zd lights\n", lctx->lights.size); build_shadow_maps (lctx, ctx); create_light_matrices (lctx); locate_lights (model, lctx); for (size_t i = 0; i < lctx->lights.size; i++) { dump_light (&lctx->lights.a[i], lctx->lightleafs.a[i], lctx->lightmats.a[i]); } }