mirror of
https://git.code.sf.net/p/quake/quakeforge
synced 2025-02-01 13:30:42 +00:00
bce7d5b832
This moves the common camera setup code out of the individual drivers, and completely removes vup/vright/vpn from the non-software renderers. This has highlighted the craziness around AngleVectors with it putting +X forward, -Y right and +Z up. The main issue with this is it requires a 90 degree pre-rotation about the Z axis to get the camera pointing in the right direction, and that's for the native sw renderer (vulkan needs a 90 degree pre-rotation about X, and gl and glsl need to invert an axis, too), though at least it's just a matrix swizzle and vector negation. However, it does mean the camera matrices can't be used directly. Also rename vpn to vfwd (still abbreviated, but fwd is much clearer in meaning (to me, at least) than pn (plane normal, I guess, but which way?)).
1018 lines
29 KiB
C
1018 lines
29 KiB
C
/*
|
|
vulkan_lighting.c
|
|
|
|
Vulkan lighting pass pipeline
|
|
|
|
Copyright (C) 2021 Bill Currie <bill@taniwha.org>
|
|
|
|
Author: Bill Currie <bill@taniwha.org>
|
|
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 <string.h>
|
|
#endif
|
|
#ifdef HAVE_STRINGS_H
|
|
# include <strings.h>
|
|
#endif
|
|
#include <stdlib.h>
|
|
|
|
#include "qfalloca.h"
|
|
|
|
#include "QF/cvar.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_refdef.frame.position[0], 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;
|
|
|
|
qfvPushDebug (ctx, "lighting init");
|
|
|
|
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_CreateGraphicsPipeline (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);
|
|
size_t light_size = QFV_NextOffset (requirements.size, &requirements);
|
|
lctx->light_memory = QFV_AllocBufferMemory (device, lbuffers->a[0],
|
|
VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT,
|
|
frames * light_size, 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 += light_size;
|
|
|
|
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
|
|
= min (MaxLights,
|
|
device->physDev->properties.limits.maxPerStageDescriptorSamplers);
|
|
lframe->shadowWrite.pImageInfo = lframe->shadowInfo;
|
|
}
|
|
free (attach_set);
|
|
free (lights_set);
|
|
qfvPopDebug (ctx);
|
|
}
|
|
|
|
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]);
|
|
}
|
|
}
|