qf/quakeforge
0
0
Fork 0
mirror of https://git.code.sf.net/p/quake/quakeforge synced 2024-11-30 16:10:53 +00:00
Code Issues Projects Releases Packages Wiki Activity
quakeforge/libs/video/renderer/vulkan/render.c

689 lines
19 KiB
C
Raw Normal View History

[vulkan] Begin work on a new render pass system While the old system did get things going, it felt clunky to set up, especially when it came to variations on render passes (eg, flat vs cube-mapped). Also, much of it felt inside-out, especially the separation of pipelines and render passes: having to specify the render pass and subpass in the pipeline spec made the spec feel overly coupled to the render pass setup. While this is the case in Vulkan, it is not reflected properly in the pipeline spec. The new system will adjust the render pass and subpass parameters of the pipeline spec as needed, making the pipeline specs more reusable, and hopefully less error prone as the pipelines are directly referenced by the subpasses that use them. In addition, subpass dependencies should be much easier to set up as only the dependent subpass specifies the dependency and the subpass source dependency is mentioned by name. Frame buffer attachments also get a similar treatment. The new spec "format" isn't quite finalized (needs to meet the enemy known as parsing) but it feels like a good starting place.
2023-01-30 04:00:35 +00:00
/*
render.c
Vulkan render manager
Copyright (C) 2023 Bill Currie <bill@taniwha.org>
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_MATH_H
# include <math.h>
#endif
#ifdef HAVE_STRING_H
# include <string.h>
#endif
#ifdef HAVE_STRINGS_H
# include <strings.h>
#endif
[vulkan] Create the render images and views And tear them down again on shutdown. The images and views are in a qfv_resource_t block, making their management much easier.
2023-02-19 03:53:02 +00:00
#include "QF/cmem.h"
[vulkan] Implement task function parsing This just sets up the memory block and cexpr descriptors for the parameters, parameter parsing is separate (and next). The parameters are aligned to their size.
2023-02-12 16:43:17 +00:00
#include "QF/hash.h"
[vulkan] Show timings for the job and steps No real surprises anywhere other than how long things can take at random times.
2023-07-13 09:33:31 +00:00
#include "QF/mathlib.h"
[vulkan] Try to create render passes and pipelines The render passes seem to be created successfully, but pipelines fail due to not having layout set, resulting in a segfault (bug in validation layers?).
2023-02-20 15:44:26 +00:00
#include "QF/va.h"
[vulkan] Begin work on a new render pass system While the old system did get things going, it felt clunky to set up, especially when it came to variations on render passes (eg, flat vs cube-mapped). Also, much of it felt inside-out, especially the separation of pipelines and render passes: having to specify the render pass and subpass in the pipeline spec made the spec feel overly coupled to the render pass setup. While this is the case in Vulkan, it is not reflected properly in the pipeline spec. The new system will adjust the render pass and subpass parameters of the pipeline spec as needed, making the pipeline specs more reusable, and hopefully less error prone as the pipelines are directly referenced by the subpasses that use them. In addition, subpass dependencies should be much easier to set up as only the dependent subpass specifies the dependency and the subpass source dependency is mentioned by name. Frame buffer attachments also get a similar treatment. The new spec "format" isn't quite finalized (needs to meet the enemy known as parsing) but it feels like a good starting place.
2023-01-30 04:00:35 +00:00
#include "QF/Vulkan/command.h"
#include "QF/Vulkan/debug.h"
#include "QF/Vulkan/device.h"
[vulkan] Create a descriptor set manager The manager allows recycling of descriptor sets and takes care of creating pools as needed.
2023-06-24 05:55:46 +00:00
#include "QF/Vulkan/dsmanager.h"
[vulkan] Pass validation for the first frame The new render system now passes validation for the first frame (but no drawing is done by the various subsystems yet). Something is wrong with how swap chain semaphores are handled thus the second frame fails. Frame buffer attachments can now be defined externally, with "$swapchain" supported for now (in which case, the swap chain defines the size of the frame buffer). Also, render pass render areas and pipeline viewport and scissor rects are updated when necessary.
2023-06-20 06:18:58 +00:00
#include "QF/Vulkan/image.h"
#include "QF/Vulkan/pipeline.h"
[vulkan] Begin work on a new render pass system While the old system did get things going, it felt clunky to set up, especially when it came to variations on render passes (eg, flat vs cube-mapped). Also, much of it felt inside-out, especially the separation of pipelines and render passes: having to specify the render pass and subpass in the pipeline spec made the spec feel overly coupled to the render pass setup. While this is the case in Vulkan, it is not reflected properly in the pipeline spec. The new system will adjust the render pass and subpass parameters of the pipeline spec as needed, making the pipeline specs more reusable, and hopefully less error prone as the pipelines are directly referenced by the subpasses that use them. In addition, subpass dependencies should be much easier to set up as only the dependent subpass specifies the dependency and the subpass source dependency is mentioned by name. Frame buffer attachments also get a similar treatment. The new spec "format" isn't quite finalized (needs to meet the enemy known as parsing) but it feels like a good starting place.
2023-01-30 04:00:35 +00:00
#include "QF/Vulkan/render.h"
[vulkan] Create the render images and views And tear them down again on shutdown. The images and views are in a qfv_resource_t block, making their management much easier.
2023-02-19 03:53:02 +00:00
#include "QF/Vulkan/resource.h"
[vulkan] Pass validation for the first frame The new render system now passes validation for the first frame (but no drawing is done by the various subsystems yet). Something is wrong with how swap chain semaphores are handled thus the second frame fails. Frame buffer attachments can now be defined externally, with "$swapchain" supported for now (in which case, the swap chain defines the size of the frame buffer). Also, render pass render areas and pipeline viewport and scissor rects are updated when necessary.
2023-06-20 06:18:58 +00:00
#include "QF/Vulkan/swapchain.h"
[vulkan] Begin work on a new render pass system While the old system did get things going, it felt clunky to set up, especially when it came to variations on render passes (eg, flat vs cube-mapped). Also, much of it felt inside-out, especially the separation of pipelines and render passes: having to specify the render pass and subpass in the pipeline spec made the spec feel overly coupled to the render pass setup. While this is the case in Vulkan, it is not reflected properly in the pipeline spec. The new system will adjust the render pass and subpass parameters of the pipeline spec as needed, making the pipeline specs more reusable, and hopefully less error prone as the pipelines are directly referenced by the subpasses that use them. In addition, subpass dependencies should be much easier to set up as only the dependent subpass specifies the dependency and the subpass source dependency is mentioned by name. Frame buffer attachments also get a similar treatment. The new spec "format" isn't quite finalized (needs to meet the enemy known as parsing) but it feels like a good starting place.
2023-01-30 04:00:35 +00:00
#include "vid_vulkan.h"
[vulkan] Attempt to load the render info spec It fails due to not supporting labeled arrays yet. I'm currently thinking about the design for vkgen.
2023-02-10 02:04:11 +00:00
#include "vkparse.h"
[vulkan] Get some subsystems passing validation This is with the new render job scheme. I very much doubt it actually works (can't start testing until everything passes, and it's disabled for the moment (define in vid_render_vulkan.c)), but it's helping iron out what more is needed in the render system.
2023-06-15 06:17:39 +00:00
VkCommandBuffer
[vulkan] Use a command buffer pool manager Many thanks to Peter and Darian for clearing up my misunderstanding of how vkResetCommandPool works. The manager creates command buffers from the command pool on an as-needed basis (when the queue of available buffers is empty), and keeps track of those buffers in a queue. When the pool is reset, the queues (one each for primary and secondary command buffers) are reset such that the tracked buffers are available again.
2023-06-22 08:00:10 +00:00
QFV_GetCmdBuffer (vulkan_ctx_t *ctx, bool secondary)
[vulkan] Stub out the basic job execution Really, a bit more than stub as the basic code is there, but nothing works properly yet due to missing resources (especially descriptor sets and pools), and the frame buffer creation is still disabled.
2023-03-28 01:28:44 +00:00
{
[vulkan] Use a command buffer pool manager Many thanks to Peter and Darian for clearing up my misunderstanding of how vkResetCommandPool works. The manager creates command buffers from the command pool on an as-needed basis (when the queue of available buffers is empty), and keeps track of those buffers in a queue. When the pool is reset, the queues (one each for primary and secondary command buffers) are reset such that the tracked buffers are available again.
2023-06-22 08:00:10 +00:00
auto rctx = ctx->render_context;
auto rframe = &rctx->frames.a[ctx->curFrame];
return QFV_CmdPoolManager_CmdBuffer (&rframe->cmdpool, secondary);
[vulkan] Stub out the basic job execution Really, a bit more than stub as the basic code is there, but nothing works properly yet due to missing resources (especially descriptor sets and pools), and the frame buffer creation is still disabled.
2023-03-28 01:28:44 +00:00
}
[vulkan] Get some subsystems passing validation This is with the new render job scheme. I very much doubt it actually works (can't start testing until everything passes, and it's disabled for the moment (define in vid_render_vulkan.c)), but it's helping iron out what more is needed in the render system.
2023-06-15 06:17:39 +00:00
void
QFV_AppendCmdBuffer (vulkan_ctx_t *ctx, VkCommandBuffer cmd)
{
__auto_type rctx = ctx->render_context;
__auto_type job = rctx->job;
DARRAY_APPEND (&job->commands, cmd);
}
[vulkan] Show timings for the job and steps No real surprises anywhere other than how long things can take at random times.
2023-07-13 09:33:31 +00:00
static void
update_time (qfv_time_t *time, int64_t start, int64_t end)
{
int64_t delta = end - start;
time->cur_time = delta;
time->min_time = min (time->min_time, delta);
time->max_time = max (time->max_time, delta);
}
[vulkan] Stub out the basic job execution Really, a bit more than stub as the basic code is there, but nothing works properly yet due to missing resources (especially descriptor sets and pools), and the frame buffer creation is still disabled.
2023-03-28 01:28:44 +00:00
static void
[vulkan] Get some subsystems passing validation This is with the new render job scheme. I very much doubt it actually works (can't start testing until everything passes, and it's disabled for the moment (define in vid_render_vulkan.c)), but it's helping iron out what more is needed in the render system.
2023-06-15 06:17:39 +00:00
run_tasks (uint32_t task_count, qfv_taskinfo_t *tasks, qfv_taskctx_t *ctx)
[vulkan] Stub out the basic job execution Really, a bit more than stub as the basic code is there, but nothing works properly yet due to missing resources (especially descriptor sets and pools), and the frame buffer creation is still disabled.
2023-03-28 01:28:44 +00:00
{
for (uint32_t i = 0; i < task_count; i++) {
[vulkan] Get some subsystems passing validation This is with the new render job scheme. I very much doubt it actually works (can't start testing until everything passes, and it's disabled for the moment (define in vid_render_vulkan.c)), but it's helping iron out what more is needed in the render system.
2023-06-15 06:17:39 +00:00
tasks[i].func->func (tasks[i].params, 0, (exprctx_t *) ctx);
[vulkan] Stub out the basic job execution Really, a bit more than stub as the basic code is there, but nothing works properly yet due to missing resources (especially descriptor sets and pools), and the frame buffer creation is still disabled.
2023-03-28 01:28:44 +00:00
}
}
[vulkan] Begin work on a new render pass system While the old system did get things going, it felt clunky to set up, especially when it came to variations on render passes (eg, flat vs cube-mapped). Also, much of it felt inside-out, especially the separation of pipelines and render passes: having to specify the render pass and subpass in the pipeline spec made the spec feel overly coupled to the render pass setup. While this is the case in Vulkan, it is not reflected properly in the pipeline spec. The new system will adjust the render pass and subpass parameters of the pipeline spec as needed, making the pipeline specs more reusable, and hopefully less error prone as the pipelines are directly referenced by the subpasses that use them. In addition, subpass dependencies should be much easier to set up as only the dependent subpass specifies the dependency and the subpass source dependency is mentioned by name. Frame buffer attachments also get a similar treatment. The new spec "format" isn't quite finalized (needs to meet the enemy known as parsing) but it feels like a good starting place.
2023-01-30 04:00:35 +00:00
static void
[vulkan] Get lighting mostly working Lights seem to be good in renderdoc, but still need to get the compose subpass working.
2023-06-22 12:36:14 +00:00
run_pipeline (qfv_pipeline_t *pipeline, qfv_taskctx_t *taskctx)
[vulkan] Begin work on a new render pass system While the old system did get things going, it felt clunky to set up, especially when it came to variations on render passes (eg, flat vs cube-mapped). Also, much of it felt inside-out, especially the separation of pipelines and render passes: having to specify the render pass and subpass in the pipeline spec made the spec feel overly coupled to the render pass setup. While this is the case in Vulkan, it is not reflected properly in the pipeline spec. The new system will adjust the render pass and subpass parameters of the pipeline spec as needed, making the pipeline specs more reusable, and hopefully less error prone as the pipelines are directly referenced by the subpasses that use them. In addition, subpass dependencies should be much easier to set up as only the dependent subpass specifies the dependency and the subpass source dependency is mentioned by name. Frame buffer attachments also get a similar treatment. The new spec "format" isn't quite finalized (needs to meet the enemy known as parsing) but it feels like a good starting place.
2023-01-30 04:00:35 +00:00
{
[vulkan] Support disabling pipelines This is useful for selecting post-processing pipelines at run-time.
2023-06-26 02:54:28 +00:00
if (pipeline->disabled) {
return;
}
[vulkan] Get lighting mostly working Lights seem to be good in renderdoc, but still need to get the compose subpass working.
2023-06-22 12:36:14 +00:00
qfv_device_t *device = taskctx->ctx->device;
[vulkan] Begin work on a new render pass system While the old system did get things going, it felt clunky to set up, especially when it came to variations on render passes (eg, flat vs cube-mapped). Also, much of it felt inside-out, especially the separation of pipelines and render passes: having to specify the render pass and subpass in the pipeline spec made the spec feel overly coupled to the render pass setup. While this is the case in Vulkan, it is not reflected properly in the pipeline spec. The new system will adjust the render pass and subpass parameters of the pipeline spec as needed, making the pipeline specs more reusable, and hopefully less error prone as the pipelines are directly referenced by the subpasses that use them. In addition, subpass dependencies should be much easier to set up as only the dependent subpass specifies the dependency and the subpass source dependency is mentioned by name. Frame buffer attachments also get a similar treatment. The new spec "format" isn't quite finalized (needs to meet the enemy known as parsing) but it feels like a good starting place.
2023-01-30 04:00:35 +00:00
qfv_devfuncs_t *dfunc = device->funcs;
[vulkan] Get lighting mostly working Lights seem to be good in renderdoc, but still need to get the compose subpass working.
2023-06-22 12:36:14 +00:00
auto cmd = taskctx->cmd;
[vulkan] Begin work on a new render pass system While the old system did get things going, it felt clunky to set up, especially when it came to variations on render passes (eg, flat vs cube-mapped). Also, much of it felt inside-out, especially the separation of pipelines and render passes: having to specify the render pass and subpass in the pipeline spec made the spec feel overly coupled to the render pass setup. While this is the case in Vulkan, it is not reflected properly in the pipeline spec. The new system will adjust the render pass and subpass parameters of the pipeline spec as needed, making the pipeline specs more reusable, and hopefully less error prone as the pipelines are directly referenced by the subpasses that use them. In addition, subpass dependencies should be much easier to set up as only the dependent subpass specifies the dependency and the subpass source dependency is mentioned by name. Frame buffer attachments also get a similar treatment. The new spec "format" isn't quite finalized (needs to meet the enemy known as parsing) but it feels like a good starting place.
2023-01-30 04:00:35 +00:00
dfunc->vkCmdBindPipeline (cmd, pipeline->bindPoint, pipeline->pipeline);
dfunc->vkCmdSetViewport (cmd, 0, 1, &pipeline->viewport);
dfunc->vkCmdSetScissor (cmd, 0, 1, &pipeline->scissor);
[vulkan] Stub out the basic job execution Really, a bit more than stub as the basic code is there, but nothing works properly yet due to missing resources (especially descriptor sets and pools), and the frame buffer creation is still disabled.
2023-03-28 01:28:44 +00:00
[vulkan] Get lighting mostly working Lights seem to be good in renderdoc, but still need to get the compose subpass working.
2023-06-22 12:36:14 +00:00
taskctx->pipeline = pipeline;
run_tasks (pipeline->task_count, pipeline->tasks, taskctx);
[vulkan] Begin work on a new render pass system While the old system did get things going, it felt clunky to set up, especially when it came to variations on render passes (eg, flat vs cube-mapped). Also, much of it felt inside-out, especially the separation of pipelines and render passes: having to specify the render pass and subpass in the pipeline spec made the spec feel overly coupled to the render pass setup. While this is the case in Vulkan, it is not reflected properly in the pipeline spec. The new system will adjust the render pass and subpass parameters of the pipeline spec as needed, making the pipeline specs more reusable, and hopefully less error prone as the pipelines are directly referenced by the subpasses that use them. In addition, subpass dependencies should be much easier to set up as only the dependent subpass specifies the dependency and the subpass source dependency is mentioned by name. Frame buffer attachments also get a similar treatment. The new spec "format" isn't quite finalized (needs to meet the enemy known as parsing) but it feels like a good starting place.
2023-01-30 04:00:35 +00:00
}
// https://themaister.net/blog/2019/08/14/yet-another-blog-explaining-vulkan-synchronization/
static void
[vulkan] Get lighting mostly working Lights seem to be good in renderdoc, but still need to get the compose subpass working.
2023-06-22 12:36:14 +00:00
run_subpass (qfv_subpass_t *sp, qfv_taskctx_t *taskctx)
[vulkan] Begin work on a new render pass system While the old system did get things going, it felt clunky to set up, especially when it came to variations on render passes (eg, flat vs cube-mapped). Also, much of it felt inside-out, especially the separation of pipelines and render passes: having to specify the render pass and subpass in the pipeline spec made the spec feel overly coupled to the render pass setup. While this is the case in Vulkan, it is not reflected properly in the pipeline spec. The new system will adjust the render pass and subpass parameters of the pipeline spec as needed, making the pipeline specs more reusable, and hopefully less error prone as the pipelines are directly referenced by the subpasses that use them. In addition, subpass dependencies should be much easier to set up as only the dependent subpass specifies the dependency and the subpass source dependency is mentioned by name. Frame buffer attachments also get a similar treatment. The new spec "format" isn't quite finalized (needs to meet the enemy known as parsing) but it feels like a good starting place.
2023-01-30 04:00:35 +00:00
{
[vulkan] Get lighting mostly working Lights seem to be good in renderdoc, but still need to get the compose subpass working.
2023-06-22 12:36:14 +00:00
qfv_device_t *device = taskctx->ctx->device;
[vulkan] Begin work on a new render pass system While the old system did get things going, it felt clunky to set up, especially when it came to variations on render passes (eg, flat vs cube-mapped). Also, much of it felt inside-out, especially the separation of pipelines and render passes: having to specify the render pass and subpass in the pipeline spec made the spec feel overly coupled to the render pass setup. While this is the case in Vulkan, it is not reflected properly in the pipeline spec. The new system will adjust the render pass and subpass parameters of the pipeline spec as needed, making the pipeline specs more reusable, and hopefully less error prone as the pipelines are directly referenced by the subpasses that use them. In addition, subpass dependencies should be much easier to set up as only the dependent subpass specifies the dependency and the subpass source dependency is mentioned by name. Frame buffer attachments also get a similar treatment. The new spec "format" isn't quite finalized (needs to meet the enemy known as parsing) but it feels like a good starting place.
2023-01-30 04:00:35 +00:00
qfv_devfuncs_t *dfunc = device->funcs;
[vulkan] Get lighting mostly working Lights seem to be good in renderdoc, but still need to get the compose subpass working.
2023-06-22 12:36:14 +00:00
dfunc->vkBeginCommandBuffer (taskctx->cmd, &sp->beginInfo);
[vulkan] Begin work on a new render pass system While the old system did get things going, it felt clunky to set up, especially when it came to variations on render passes (eg, flat vs cube-mapped). Also, much of it felt inside-out, especially the separation of pipelines and render passes: having to specify the render pass and subpass in the pipeline spec made the spec feel overly coupled to the render pass setup. While this is the case in Vulkan, it is not reflected properly in the pipeline spec. The new system will adjust the render pass and subpass parameters of the pipeline spec as needed, making the pipeline specs more reusable, and hopefully less error prone as the pipelines are directly referenced by the subpasses that use them. In addition, subpass dependencies should be much easier to set up as only the dependent subpass specifies the dependency and the subpass source dependency is mentioned by name. Frame buffer attachments also get a similar treatment. The new spec "format" isn't quite finalized (needs to meet the enemy known as parsing) but it feels like a good starting place.
2023-01-30 04:00:35 +00:00
[vulkan] Try to create render passes and pipelines The render passes seem to be created successfully, but pipelines fail due to not having layout set, resulting in a segfault (bug in validation layers?).
2023-02-20 15:44:26 +00:00
for (uint32_t i = 0; i < sp->pipeline_count; i++) {
[vulkan] Begin work on a new render pass system While the old system did get things going, it felt clunky to set up, especially when it came to variations on render passes (eg, flat vs cube-mapped). Also, much of it felt inside-out, especially the separation of pipelines and render passes: having to specify the render pass and subpass in the pipeline spec made the spec feel overly coupled to the render pass setup. While this is the case in Vulkan, it is not reflected properly in the pipeline spec. The new system will adjust the render pass and subpass parameters of the pipeline spec as needed, making the pipeline specs more reusable, and hopefully less error prone as the pipelines are directly referenced by the subpasses that use them. In addition, subpass dependencies should be much easier to set up as only the dependent subpass specifies the dependency and the subpass source dependency is mentioned by name. Frame buffer attachments also get a similar treatment. The new spec "format" isn't quite finalized (needs to meet the enemy known as parsing) but it feels like a good starting place.
2023-01-30 04:00:35 +00:00
__auto_type pipeline = &sp->pipelines[i];
[vulkan] Get lighting mostly working Lights seem to be good in renderdoc, but still need to get the compose subpass working.
2023-06-22 12:36:14 +00:00
run_pipeline (pipeline, taskctx);
[vulkan] Begin work on a new render pass system While the old system did get things going, it felt clunky to set up, especially when it came to variations on render passes (eg, flat vs cube-mapped). Also, much of it felt inside-out, especially the separation of pipelines and render passes: having to specify the render pass and subpass in the pipeline spec made the spec feel overly coupled to the render pass setup. While this is the case in Vulkan, it is not reflected properly in the pipeline spec. The new system will adjust the render pass and subpass parameters of the pipeline spec as needed, making the pipeline specs more reusable, and hopefully less error prone as the pipelines are directly referenced by the subpasses that use them. In addition, subpass dependencies should be much easier to set up as only the dependent subpass specifies the dependency and the subpass source dependency is mentioned by name. Frame buffer attachments also get a similar treatment. The new spec "format" isn't quite finalized (needs to meet the enemy known as parsing) but it feels like a good starting place.
2023-01-30 04:00:35 +00:00
}
[vulkan] Get lighting mostly working Lights seem to be good in renderdoc, but still need to get the compose subpass working.
2023-06-22 12:36:14 +00:00
dfunc->vkEndCommandBuffer (taskctx->cmd);
[vulkan] Begin work on a new render pass system While the old system did get things going, it felt clunky to set up, especially when it came to variations on render passes (eg, flat vs cube-mapped). Also, much of it felt inside-out, especially the separation of pipelines and render passes: having to specify the render pass and subpass in the pipeline spec made the spec feel overly coupled to the render pass setup. While this is the case in Vulkan, it is not reflected properly in the pipeline spec. The new system will adjust the render pass and subpass parameters of the pipeline spec as needed, making the pipeline specs more reusable, and hopefully less error prone as the pipelines are directly referenced by the subpasses that use them. In addition, subpass dependencies should be much easier to set up as only the dependent subpass specifies the dependency and the subpass source dependency is mentioned by name. Frame buffer attachments also get a similar treatment. The new spec "format" isn't quite finalized (needs to meet the enemy known as parsing) but it feels like a good starting place.
2023-01-30 04:00:35 +00:00
}
[vulkan] Stub out the basic job execution Really, a bit more than stub as the basic code is there, but nothing works properly yet due to missing resources (especially descriptor sets and pools), and the frame buffer creation is still disabled.
2023-03-28 01:28:44 +00:00
static void
[vulkan] Switch around renderpass and subpass names The old structs will go away eventually, and I'm tired of seeing that _ tail.
2023-06-15 04:13:52 +00:00
run_renderpass (qfv_renderpass_t *rp, vulkan_ctx_t *ctx)
[vulkan] Begin work on a new render pass system While the old system did get things going, it felt clunky to set up, especially when it came to variations on render passes (eg, flat vs cube-mapped). Also, much of it felt inside-out, especially the separation of pipelines and render passes: having to specify the render pass and subpass in the pipeline spec made the spec feel overly coupled to the render pass setup. While this is the case in Vulkan, it is not reflected properly in the pipeline spec. The new system will adjust the render pass and subpass parameters of the pipeline spec as needed, making the pipeline specs more reusable, and hopefully less error prone as the pipelines are directly referenced by the subpasses that use them. In addition, subpass dependencies should be much easier to set up as only the dependent subpass specifies the dependency and the subpass source dependency is mentioned by name. Frame buffer attachments also get a similar treatment. The new spec "format" isn't quite finalized (needs to meet the enemy known as parsing) but it feels like a good starting place.
2023-01-30 04:00:35 +00:00
{
qfv_device_t *device = ctx->device;
qfv_devfuncs_t *dfunc = device->funcs;
[vulkan] Get some subsystems passing validation This is with the new render job scheme. I very much doubt it actually works (can't start testing until everything passes, and it's disabled for the moment (define in vid_render_vulkan.c)), but it's helping iron out what more is needed in the render system.
2023-06-15 06:17:39 +00:00
__auto_type rctx = ctx->render_context;
__auto_type job = rctx->job;
[vulkan] Begin work on a new render pass system While the old system did get things going, it felt clunky to set up, especially when it came to variations on render passes (eg, flat vs cube-mapped). Also, much of it felt inside-out, especially the separation of pipelines and render passes: having to specify the render pass and subpass in the pipeline spec made the spec feel overly coupled to the render pass setup. While this is the case in Vulkan, it is not reflected properly in the pipeline spec. The new system will adjust the render pass and subpass parameters of the pipeline spec as needed, making the pipeline specs more reusable, and hopefully less error prone as the pipelines are directly referenced by the subpasses that use them. In addition, subpass dependencies should be much easier to set up as only the dependent subpass specifies the dependency and the subpass source dependency is mentioned by name. Frame buffer attachments also get a similar treatment. The new spec "format" isn't quite finalized (needs to meet the enemy known as parsing) but it feels like a good starting place.
2023-01-30 04:00:35 +00:00
[vulkan] Use a command buffer pool manager Many thanks to Peter and Darian for clearing up my misunderstanding of how vkResetCommandPool works. The manager creates command buffers from the command pool on an as-needed basis (when the queue of available buffers is empty), and keeps track of those buffers in a queue. When the pool is reset, the queues (one each for primary and secondary command buffers) are reset such that the tracked buffers are available again.
2023-06-22 08:00:10 +00:00
VkCommandBuffer cmd = QFV_GetCmdBuffer (ctx, false);
[vulkan] Get particles mostly working in the new system The particles die instantly due to curFrame not updating (next commit), but otherwise work nicely, especially sync is better (many thanks to Darian for his help with understanding sync scope).
2023-06-23 18:26:22 +00:00
QFV_duSetObjectName (device, VK_OBJECT_TYPE_COMMAND_BUFFER, cmd,
va (ctx->va_ctx, "cmd:render:%s", rp->label.name));
[vulkan] Begin work on a new render pass system While the old system did get things going, it felt clunky to set up, especially when it came to variations on render passes (eg, flat vs cube-mapped). Also, much of it felt inside-out, especially the separation of pipelines and render passes: having to specify the render pass and subpass in the pipeline spec made the spec feel overly coupled to the render pass setup. While this is the case in Vulkan, it is not reflected properly in the pipeline spec. The new system will adjust the render pass and subpass parameters of the pipeline spec as needed, making the pipeline specs more reusable, and hopefully less error prone as the pipelines are directly referenced by the subpasses that use them. In addition, subpass dependencies should be much easier to set up as only the dependent subpass specifies the dependency and the subpass source dependency is mentioned by name. Frame buffer attachments also get a similar treatment. The new spec "format" isn't quite finalized (needs to meet the enemy known as parsing) but it feels like a good starting place.
2023-01-30 04:00:35 +00:00
VkCommandBufferBeginInfo beginInfo = {
VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
};
dfunc->vkBeginCommandBuffer (cmd, &beginInfo);
QFV_duCmdBeginLabel (device, cmd, rp->label.name,
{VEC4_EXP (rp->label.color)});
dfunc->vkCmdBeginRenderPass (cmd, &rp->beginInfo, rp->subpassContents);
for (uint32_t i = 0; i < rp->subpass_count; i++) {
__auto_type sp = &rp->subpasses[i];
[vulkan] Move the subpass command labels out a layer Just for easier debugging in renderdoc.
2023-06-22 11:30:10 +00:00
QFV_duCmdBeginLabel (device, cmd, sp->label.name,
{VEC4_EXP (sp->label.color)});
[vulkan] Get lighting mostly working Lights seem to be good in renderdoc, but still need to get the compose subpass working.
2023-06-22 12:36:14 +00:00
qfv_taskctx_t taskctx = {
.ctx = ctx,
.renderpass = rp,
.cmd = QFV_GetCmdBuffer (ctx, true),
};
run_subpass (sp, &taskctx);
dfunc->vkCmdExecuteCommands (cmd, 1, &taskctx.cmd);
[vulkan] Move the subpass command labels out a layer Just for easier debugging in renderdoc.
2023-06-22 11:30:10 +00:00
QFV_duCmdEndLabel (device, cmd);
[vulkan] Begin work on a new render pass system While the old system did get things going, it felt clunky to set up, especially when it came to variations on render passes (eg, flat vs cube-mapped). Also, much of it felt inside-out, especially the separation of pipelines and render passes: having to specify the render pass and subpass in the pipeline spec made the spec feel overly coupled to the render pass setup. While this is the case in Vulkan, it is not reflected properly in the pipeline spec. The new system will adjust the render pass and subpass parameters of the pipeline spec as needed, making the pipeline specs more reusable, and hopefully less error prone as the pipelines are directly referenced by the subpasses that use them. In addition, subpass dependencies should be much easier to set up as only the dependent subpass specifies the dependency and the subpass source dependency is mentioned by name. Frame buffer attachments also get a similar treatment. The new spec "format" isn't quite finalized (needs to meet the enemy known as parsing) but it feels like a good starting place.
2023-01-30 04:00:35 +00:00
//FIXME comment is a bit off as exactly one buffer is always submitted
//
//Regardless of whether any commands were submitted for this
//subpass, must step through each and every subpass, otherwise
//the attachments won't be transitioned correctly.
//However, only if not the last (or only) subpass.
if (i < rp->subpass_count - 1) {
dfunc->vkCmdNextSubpass (cmd, rp->subpassContents);
}
}
[vulkan] Use per-swapchain images for output framebuffers Imageless framebuffers would probably be easier and cleaner, but this takes care of the validation error attempting to present the second frame (because rendering was being done to the first frame's swapchain image instead of the second frame's).
2023-06-21 05:47:19 +00:00
dfunc->vkCmdEndRenderPass (cmd);
[vulkan] Begin work on a new render pass system While the old system did get things going, it felt clunky to set up, especially when it came to variations on render passes (eg, flat vs cube-mapped). Also, much of it felt inside-out, especially the separation of pipelines and render passes: having to specify the render pass and subpass in the pipeline spec made the spec feel overly coupled to the render pass setup. While this is the case in Vulkan, it is not reflected properly in the pipeline spec. The new system will adjust the render pass and subpass parameters of the pipeline spec as needed, making the pipeline specs more reusable, and hopefully less error prone as the pipelines are directly referenced by the subpasses that use them. In addition, subpass dependencies should be much easier to set up as only the dependent subpass specifies the dependency and the subpass source dependency is mentioned by name. Frame buffer attachments also get a similar treatment. The new spec "format" isn't quite finalized (needs to meet the enemy known as parsing) but it feels like a good starting place.
2023-01-30 04:00:35 +00:00
QFV_CmdEndLabel (device, cmd);
[vulkan] Use per-swapchain images for output framebuffers Imageless framebuffers would probably be easier and cleaner, but this takes care of the validation error attempting to present the second frame (because rendering was being done to the first frame's swapchain image instead of the second frame's).
2023-06-21 05:47:19 +00:00
dfunc->vkEndCommandBuffer (cmd);
[vulkan] Get some subsystems passing validation This is with the new render job scheme. I very much doubt it actually works (can't start testing until everything passes, and it's disabled for the moment (define in vid_render_vulkan.c)), but it's helping iron out what more is needed in the render system.
2023-06-15 06:17:39 +00:00
DARRAY_APPEND (&job->commands, cmd);
[vulkan] Begin work on a new render pass system While the old system did get things going, it felt clunky to set up, especially when it came to variations on render passes (eg, flat vs cube-mapped). Also, much of it felt inside-out, especially the separation of pipelines and render passes: having to specify the render pass and subpass in the pipeline spec made the spec feel overly coupled to the render pass setup. While this is the case in Vulkan, it is not reflected properly in the pipeline spec. The new system will adjust the render pass and subpass parameters of the pipeline spec as needed, making the pipeline specs more reusable, and hopefully less error prone as the pipelines are directly referenced by the subpasses that use them. In addition, subpass dependencies should be much easier to set up as only the dependent subpass specifies the dependency and the subpass source dependency is mentioned by name. Frame buffer attachments also get a similar treatment. The new spec "format" isn't quite finalized (needs to meet the enemy known as parsing) but it feels like a good starting place.
2023-01-30 04:00:35 +00:00
}
[vulkan] Attempt to load the render info spec It fails due to not supporting labeled arrays yet. I'm currently thinking about the design for vkgen.
2023-02-10 02:04:11 +00:00
[vulkan] Stub out the basic job execution Really, a bit more than stub as the basic code is there, but nothing works properly yet due to missing resources (especially descriptor sets and pools), and the frame buffer creation is still disabled.
2023-03-28 01:28:44 +00:00
static void
run_compute_pipeline (qfv_pipeline_t *pipeline, VkCommandBuffer cmd,
vulkan_ctx_t *ctx)
{
[vulkan] Support disabling pipelines This is useful for selecting post-processing pipelines at run-time.
2023-06-26 02:54:28 +00:00
if (pipeline->disabled) {
return;
}
[vulkan] Stub out the basic job execution Really, a bit more than stub as the basic code is there, but nothing works properly yet due to missing resources (especially descriptor sets and pools), and the frame buffer creation is still disabled.
2023-03-28 01:28:44 +00:00
qfv_device_t *device = ctx->device;
qfv_devfuncs_t *dfunc = device->funcs;
dfunc->vkCmdBindPipeline (cmd, pipeline->bindPoint, pipeline->pipeline);
qfv_taskctx_t taskctx = {
.ctx = ctx,
.pipeline = pipeline,
[vulkan] Pass the current command buffer to tasks Compute and render tasks need to be able to submit commands.
2023-06-16 13:34:08 +00:00
.cmd = cmd,
[vulkan] Stub out the basic job execution Really, a bit more than stub as the basic code is there, but nothing works properly yet due to missing resources (especially descriptor sets and pools), and the frame buffer creation is still disabled.
2023-03-28 01:28:44 +00:00
};
run_tasks (pipeline->task_count, pipeline->tasks, &taskctx);
[vulkan] Get some subsystems passing validation This is with the new render job scheme. I very much doubt it actually works (can't start testing until everything passes, and it's disabled for the moment (define in vid_render_vulkan.c)), but it's helping iron out what more is needed in the render system.
2023-06-15 06:17:39 +00:00
vec4u_t d = pipeline->dispatch;
[vulkan] Get particles mostly working in the new system The particles die instantly due to curFrame not updating (next commit), but otherwise work nicely, especially sync is better (many thanks to Darian for his help with understanding sync scope).
2023-06-23 18:26:22 +00:00
if (d[0] && d[1] && d[2]) {
dfunc->vkCmdDispatch (cmd, d[0], d[1], d[2]);
}
[vulkan] Stub out the basic job execution Really, a bit more than stub as the basic code is there, but nothing works properly yet due to missing resources (especially descriptor sets and pools), and the frame buffer creation is still disabled.
2023-03-28 01:28:44 +00:00
}
static void
[vulkan] Get particles mostly working in the new system The particles die instantly due to curFrame not updating (next commit), but otherwise work nicely, especially sync is better (many thanks to Darian for his help with understanding sync scope).
2023-06-23 18:26:22 +00:00
run_compute (qfv_compute_t *comp, vulkan_ctx_t *ctx, qfv_step_t *step)
[vulkan] Stub out the basic job execution Really, a bit more than stub as the basic code is there, but nothing works properly yet due to missing resources (especially descriptor sets and pools), and the frame buffer creation is still disabled.
2023-03-28 01:28:44 +00:00
{
qfv_device_t *device = ctx->device;
qfv_devfuncs_t *dfunc = device->funcs;
__auto_type rctx = ctx->render_context;
__auto_type job = rctx->job;
[vulkan] Use a command buffer pool manager Many thanks to Peter and Darian for clearing up my misunderstanding of how vkResetCommandPool works. The manager creates command buffers from the command pool on an as-needed basis (when the queue of available buffers is empty), and keeps track of those buffers in a queue. When the pool is reset, the queues (one each for primary and secondary command buffers) are reset such that the tracked buffers are available again.
2023-06-22 08:00:10 +00:00
VkCommandBuffer cmd = QFV_GetCmdBuffer (ctx, false);
[vulkan] Get particles mostly working in the new system The particles die instantly due to curFrame not updating (next commit), but otherwise work nicely, especially sync is better (many thanks to Darian for his help with understanding sync scope).
2023-06-23 18:26:22 +00:00
QFV_duSetObjectName (device, VK_OBJECT_TYPE_COMMAND_BUFFER, cmd,
va (ctx->va_ctx, "cmd:compute:%s", step->label.name));
QFV_duCmdBeginLabel (device, cmd, step->label.name,
{VEC4_EXP (step->label.color)});
[vulkan] Stub out the basic job execution Really, a bit more than stub as the basic code is there, but nothing works properly yet due to missing resources (especially descriptor sets and pools), and the frame buffer creation is still disabled.
2023-03-28 01:28:44 +00:00
VkCommandBufferBeginInfo beginInfo = {
.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT,
};
dfunc->vkBeginCommandBuffer (cmd, &beginInfo);
for (uint32_t i = 0; i < comp->pipeline_count; i++) {
__auto_type pipeline = &comp->pipelines[i];
run_compute_pipeline (pipeline, cmd, ctx);
}
[vulkan] Get particles mostly working in the new system The particles die instantly due to curFrame not updating (next commit), but otherwise work nicely, especially sync is better (many thanks to Darian for his help with understanding sync scope).
2023-06-23 18:26:22 +00:00
QFV_duCmdEndLabel (device, cmd);
[vulkan] Stub out the basic job execution Really, a bit more than stub as the basic code is there, but nothing works properly yet due to missing resources (especially descriptor sets and pools), and the frame buffer creation is still disabled.
2023-03-28 01:28:44 +00:00
dfunc->vkEndCommandBuffer (cmd);
DARRAY_APPEND (&job->commands, cmd);
}
static void
run_process (qfv_process_t *proc, vulkan_ctx_t *ctx)
{
qfv_taskctx_t taskctx = {
.ctx = ctx,
};
run_tasks (proc->task_count, proc->tasks, &taskctx);
}
void
QFV_RunRenderJob (vulkan_ctx_t *ctx)
{
[vulkan] Use per-swapchain images for output framebuffers Imageless framebuffers would probably be easier and cleaner, but this takes care of the validation error attempting to present the second frame (because rendering was being done to the first frame's swapchain image instead of the second frame's).
2023-06-21 05:47:19 +00:00
auto rctx = ctx->render_context;
auto job = rctx->job;
[vulkan] Show timings for the job and steps No real surprises anywhere other than how long things can take at random times.
2023-07-13 09:33:31 +00:00
int64_t start = Sys_LongTime ();
[vulkan] Stub out the basic job execution Really, a bit more than stub as the basic code is there, but nothing works properly yet due to missing resources (especially descriptor sets and pools), and the frame buffer creation is still disabled.
2023-03-28 01:28:44 +00:00
for (uint32_t i = 0; i < job->num_steps; i++) {
[vulkan] Show timings for the job and steps No real surprises anywhere other than how long things can take at random times.
2023-07-13 09:33:31 +00:00
int64_t step_start = Sys_LongTime ();
[vulkan] Stub out the basic job execution Really, a bit more than stub as the basic code is there, but nothing works properly yet due to missing resources (especially descriptor sets and pools), and the frame buffer creation is still disabled.
2023-03-28 01:28:44 +00:00
__auto_type step = &job->steps[i];
if (step->render) {
run_renderpass (step->render->active, ctx);
}
if (step->compute) {
[vulkan] Get particles mostly working in the new system The particles die instantly due to curFrame not updating (next commit), but otherwise work nicely, especially sync is better (many thanks to Darian for his help with understanding sync scope).
2023-06-23 18:26:22 +00:00
run_compute (step->compute, ctx, step);
[vulkan] Stub out the basic job execution Really, a bit more than stub as the basic code is there, but nothing works properly yet due to missing resources (especially descriptor sets and pools), and the frame buffer creation is still disabled.
2023-03-28 01:28:44 +00:00
}
if (step->process) {
run_process (step->process, ctx);
}
[vulkan] Show timings for the job and steps No real surprises anywhere other than how long things can take at random times.
2023-07-13 09:33:31 +00:00
update_time (&step->time, step_start, Sys_LongTime ());
[vulkan] Stub out the basic job execution Really, a bit more than stub as the basic code is there, but nothing works properly yet due to missing resources (especially descriptor sets and pools), and the frame buffer creation is still disabled.
2023-03-28 01:28:44 +00:00
}
[vulkan] Use per-swapchain images for output framebuffers Imageless framebuffers would probably be easier and cleaner, but this takes care of the validation error attempting to present the second frame (because rendering was being done to the first frame's swapchain image instead of the second frame's).
2023-06-21 05:47:19 +00:00
auto device = ctx->device;
auto dfunc = device->funcs;
auto queue = &device->queue;
[vulkan] Move frames from vulkan_ctx to renderctx Part of the command buffer fix, but also a step towards cleaning up vulkan_ctx.
2023-06-22 07:44:05 +00:00
auto frame = &rctx->frames.a[ctx->curFrame];
[vulkan] Use per-swapchain images for output framebuffers Imageless framebuffers would probably be easier and cleaner, but this takes care of the validation error attempting to present the second frame (because rendering was being done to the first frame's swapchain image instead of the second frame's).
2023-06-21 05:47:19 +00:00
VkPipelineStageFlags waitStage
= VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
VkSubmitInfo submitInfo = {
VK_STRUCTURE_TYPE_SUBMIT_INFO, 0,
1, &frame->imageAvailableSemaphore, &waitStage,
job->commands.size, job->commands.a,
1, &frame->renderDoneSemaphore,
};
dfunc->vkResetFences (device->dev, 1, &frame->fence);
dfunc->vkQueueSubmit (queue->queue, 1, &submitInfo, frame->fence);
VkPresentInfoKHR presentInfo = {
VK_STRUCTURE_TYPE_PRESENT_INFO_KHR, 0,
1, &frame->renderDoneSemaphore,
1, &ctx->swapchain->swapchain, &ctx->swapImageIndex,
0
};
dfunc->vkQueuePresentKHR (queue->queue, &presentInfo);
[vulkan] Update curFrame at end of render job This fixes the insta-death of particles. Interestingly, other than particles (due to the ring of buffers not being used correctly), everything else worked nicely, so I guess 1-frame rendering got tested.
2023-06-23 18:32:21 +00:00
if (++ctx->curFrame >= rctx->frames.size) {
ctx->curFrame = 0;
}
[vulkan] Show timings for the job and steps No real surprises anywhere other than how long things can take at random times.
2023-07-13 09:33:31 +00:00
update_time (&job->time, start, Sys_LongTime ());
[vulkan] Stub out the basic job execution Really, a bit more than stub as the basic code is there, but nothing works properly yet due to missing resources (especially descriptor sets and pools), and the frame buffer creation is still disabled.
2023-03-28 01:28:44 +00:00
}
[vulkan] Get window resize working again The biggest change was splitting up the job resources into per-render-pass resources, allowing individual render passes to reallocate their resources without affecting any others. After that, it was just getting translucency and capture working after a window resize.
2023-07-03 11:05:27 +00:00
static qfv_imageviewinfo_t * __attribute__((pure))
find_imageview (qfv_reference_t *ref, qfv_renderpass_t *rp,
qfv_renderctx_t *rctx)
[vulkan] Add a step and task to create a framebuffer I don't like the current name (update_framebuffer), but if the referenced render pass doesn't have a framebuffer, one is created. The renderpass is referenced via the active renderpass of the named render step. Unfortunately, this has uncovered a bug in the setup of renderpass objects: main.deferred has output's renderpass, and main.deferred_cube and output have bogus renderpass objects.
2023-06-18 09:42:07 +00:00
{
[vulkan] Get window resize working again The biggest change was splitting up the job resources into per-render-pass resources, allowing individual render passes to reallocate their resources without affecting any others. After that, it was just getting translucency and capture working after a window resize.
2023-07-03 11:05:27 +00:00
auto jinfo = rctx->jobinfo;
[vulkan] Add a step and task to create a framebuffer I don't like the current name (update_framebuffer), but if the referenced render pass doesn't have a framebuffer, one is created. The renderpass is referenced via the active renderpass of the named render step. Unfortunately, this has uncovered a bug in the setup of renderpass objects: main.deferred has output's renderpass, and main.deferred_cube and output have bogus renderpass objects.
2023-06-18 09:42:07 +00:00
const char *name = ref->name;
if (strncmp (name, "$imageviews.", 7) == 0) {
name += 7;
}
for (uint32_t i = 0; i < jinfo->num_imageviews; i++) {
[vulkan] Get window resize working again The biggest change was splitting up the job resources into per-render-pass resources, allowing individual render passes to reallocate their resources without affecting any others. After that, it was just getting translucency and capture working after a window resize.
2023-07-03 11:05:27 +00:00
auto viewinfo = &jinfo->imageviews[i];
if (strcmp (name, viewinfo->name) == 0) {
return viewinfo;
[vulkan] Add a step and task to create a framebuffer I don't like the current name (update_framebuffer), but if the referenced render pass doesn't have a framebuffer, one is created. The renderpass is referenced via the active renderpass of the named render step. Unfortunately, this has uncovered a bug in the setup of renderpass objects: main.deferred has output's renderpass, and main.deferred_cube and output have bogus renderpass objects.
2023-06-18 09:42:07 +00:00
}
}
Sys_Error ("%d:invalid imageview: %s", ref->line, ref->name);
[vulkan] Create a framebuffer for the first render pass Currently just the one framebuffer is created, but I want to get things running soon.
2023-03-02 09:33:16 +00:00
}
[vulkan] Use per-swapchain images for output framebuffers Imageless framebuffers would probably be easier and cleaner, but this takes care of the validation error attempting to present the second frame (because rendering was being done to the first frame's swapchain image instead of the second frame's).
2023-06-21 05:47:19 +00:00
void
[vulkan] Get window resize working again The biggest change was splitting up the job resources into per-render-pass resources, allowing individual render passes to reallocate their resources without affecting any others. After that, it was just getting translucency and capture working after a window resize.
2023-07-03 11:05:27 +00:00
QFV_DestroyFramebuffer (vulkan_ctx_t *ctx, qfv_renderpass_t *rp)
[vulkan] Create a framebuffer for the first render pass Currently just the one framebuffer is created, but I want to get things running soon.
2023-03-02 09:33:16 +00:00
{
[vulkan] Get window resize working again The biggest change was splitting up the job resources into per-render-pass resources, allowing individual render passes to reallocate their resources without affecting any others. After that, it was just getting translucency and capture working after a window resize.
2023-07-03 11:05:27 +00:00
if (rp->beginInfo.framebuffer) {
auto device = ctx->device;
auto dfunc = device->funcs;
auto bi = &rp->beginInfo;
dfunc->vkDestroyFramebuffer (device->dev, bi->framebuffer, 0);
bi->framebuffer = 0;
}
if (rp->resources && rp->resources->memory) {
QFV_DestroyResource (ctx->device, rp->resources);
}
}
void
QFV_CreateFramebuffer (vulkan_ctx_t *ctx, qfv_renderpass_t *rp,
VkExtent2D extent)
{
auto rctx = ctx->render_context;
if (rp->resources && !rp->resources->memory) {
for (uint32_t i = 0; i < rp->resources->num_objects; i++) {
auto obj = &rp->resources->objects[i];
if (obj->type == qfv_res_image) {
obj->image.extent.width = extent.width;
obj->image.extent.height = extent.height;
}
}
QFV_CreateResource (ctx->device, rp->resources);
}
[vulkan] Create a framebuffer for the first render pass Currently just the one framebuffer is created, but I want to get things running soon.
2023-03-02 09:33:16 +00:00
[vulkan] Add a step and task to create a framebuffer I don't like the current name (update_framebuffer), but if the referenced render pass doesn't have a framebuffer, one is created. The renderpass is referenced via the active renderpass of the named render step. Unfortunately, this has uncovered a bug in the setup of renderpass objects: main.deferred has output's renderpass, and main.deferred_cube and output have bogus renderpass objects.
2023-06-18 09:42:07 +00:00
auto fb = rp->framebufferinfo;
[vulkan] Get lighting mostly working Lights seem to be good in renderdoc, but still need to get the compose subpass working.
2023-06-22 12:36:14 +00:00
auto attachments = rp->framebuffer.views;
[vulkan] Create a framebuffer for the first render pass Currently just the one framebuffer is created, but I want to get things running soon.
2023-03-02 09:33:16 +00:00
VkFramebufferCreateInfo cInfo = {
.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO,
[vulkan] Add a step and task to create a framebuffer I don't like the current name (update_framebuffer), but if the referenced render pass doesn't have a framebuffer, one is created. The renderpass is referenced via the active renderpass of the named render step. Unfortunately, this has uncovered a bug in the setup of renderpass objects: main.deferred has output's renderpass, and main.deferred_cube and output have bogus renderpass objects.
2023-06-18 09:42:07 +00:00
.attachmentCount = fb->num_attachments,
[vulkan] Create a framebuffer for the first render pass Currently just the one framebuffer is created, but I want to get things running soon.
2023-03-02 09:33:16 +00:00
.pAttachments = attachments,
.renderPass = rp->beginInfo.renderPass,
[vulkan] Get window resize working again The biggest change was splitting up the job resources into per-render-pass resources, allowing individual render passes to reallocate their resources without affecting any others. After that, it was just getting translucency and capture working after a window resize.
2023-07-03 11:05:27 +00:00
.width = extent.width,
.height = extent.height,
[vulkan] Add a step and task to create a framebuffer I don't like the current name (update_framebuffer), but if the referenced render pass doesn't have a framebuffer, one is created. The renderpass is referenced via the active renderpass of the named render step. Unfortunately, this has uncovered a bug in the setup of renderpass objects: main.deferred has output's renderpass, and main.deferred_cube and output have bogus renderpass objects.
2023-06-18 09:42:07 +00:00
.layers = fb->layers,
[vulkan] Create a framebuffer for the first render pass Currently just the one framebuffer is created, but I want to get things running soon.
2023-03-02 09:33:16 +00:00
};
[vulkan] Add a step and task to create a framebuffer I don't like the current name (update_framebuffer), but if the referenced render pass doesn't have a framebuffer, one is created. The renderpass is referenced via the active renderpass of the named render step. Unfortunately, this has uncovered a bug in the setup of renderpass objects: main.deferred has output's renderpass, and main.deferred_cube and output have bogus renderpass objects.
2023-06-18 09:42:07 +00:00
for (uint32_t i = 0; i < fb->num_attachments; i++) {
[vulkan] Pass validation for the first frame The new render system now passes validation for the first frame (but no drawing is done by the various subsystems yet). Something is wrong with how swap chain semaphores are handled thus the second frame fails. Frame buffer attachments can now be defined externally, with "$swapchain" supported for now (in which case, the swap chain defines the size of the frame buffer). Also, render pass render areas and pipeline viewport and scissor rects are updated when necessary.
2023-06-20 06:18:58 +00:00
if (fb->attachments[i].external) {
attachments[i] = 0;
if (!strcmp (fb->attachments[i].external, "$swapchain")) {
auto sc = ctx->swapchain;
attachments[i] = sc->imageViews->a[ctx->swapImageIndex];
cInfo.width = sc->extent.width;
cInfo.height = sc->extent.height;
}
} else {
[vulkan] Get window resize working again The biggest change was splitting up the job resources into per-render-pass resources, allowing individual render passes to reallocate their resources without affecting any others. After that, it was just getting translucency and capture working after a window resize.
2023-07-03 11:05:27 +00:00
auto viewinfo = find_imageview (&fb->attachments[i].view, rp, rctx);
attachments[i] = viewinfo->object->image_view.view;
[vulkan] Connect the main and output render steps The output system's update_input takes a parameter specifying the render step from which it is to get the output view of that step and updates its descriptors as necessary. With this, the full render job is working for alias models (minus a few glitches).
2023-06-22 15:43:34 +00:00
if (rp->outputref.name) {
[vulkan] Get window resize working again The biggest change was splitting up the job resources into per-render-pass resources, allowing individual render passes to reallocate their resources without affecting any others. After that, it was just getting translucency and capture working after a window resize.
2023-07-03 11:05:27 +00:00
viewinfo = find_imageview (&rp->outputref, rp, rctx);
rp->output = viewinfo->object->image_view.view;
[vulkan] Connect the main and output render steps The output system's update_input takes a parameter specifying the render step from which it is to get the output view of that step and updates its descriptors as necessary. With this, the full render job is working for alias models (minus a few glitches).
2023-06-22 15:43:34 +00:00
}
[vulkan] Pass validation for the first frame The new render system now passes validation for the first frame (but no drawing is done by the various subsystems yet). Something is wrong with how swap chain semaphores are handled thus the second frame fails. Frame buffer attachments can now be defined externally, with "$swapchain" supported for now (in which case, the swap chain defines the size of the frame buffer). Also, render pass render areas and pipeline viewport and scissor rects are updated when necessary.
2023-06-20 06:18:58 +00:00
}
[vulkan] Create a framebuffer for the first render pass Currently just the one framebuffer is created, but I want to get things running soon.
2023-03-02 09:33:16 +00:00
}
qfv_device_t *device = ctx->device;
qfv_devfuncs_t *dfunc = device->funcs;
VkFramebuffer framebuffer;
dfunc->vkCreateFramebuffer (device->dev, &cInfo, 0, &framebuffer);
QFV_duSetObjectName (device, VK_OBJECT_TYPE_FRAMEBUFFER, framebuffer,
[vulkan] Add a step and task to create a framebuffer I don't like the current name (update_framebuffer), but if the referenced render pass doesn't have a framebuffer, one is created. The renderpass is referenced via the active renderpass of the named render step. Unfortunately, this has uncovered a bug in the setup of renderpass objects: main.deferred has output's renderpass, and main.deferred_cube and output have bogus renderpass objects.
2023-06-18 09:42:07 +00:00
va (ctx->va_ctx, "framebuffer:%s", rp->label.name));
[vulkan] Create a framebuffer for the first render pass Currently just the one framebuffer is created, but I want to get things running soon.
2023-03-02 09:33:16 +00:00
rp->beginInfo.framebuffer = framebuffer;
for (uint32_t i = 0; i < rp->subpass_count; i++) {
__auto_type sp = &rp->subpasses[i];
sp->inherit.framebuffer = framebuffer;
}
}
[vulkan] Add a step and task to create a framebuffer I don't like the current name (update_framebuffer), but if the referenced render pass doesn't have a framebuffer, one is created. The renderpass is referenced via the active renderpass of the named render step. Unfortunately, this has uncovered a bug in the setup of renderpass objects: main.deferred has output's renderpass, and main.deferred_cube and output have bogus renderpass objects.
2023-06-18 09:42:07 +00:00
static void
wait_on_fence (const exprval_t **params, exprval_t *result, exprctx_t *ectx)
{
[vulkan] Use per-swapchain images for output framebuffers Imageless framebuffers would probably be easier and cleaner, but this takes care of the validation error attempting to present the second frame (because rendering was being done to the first frame's swapchain image instead of the second frame's).
2023-06-21 05:47:19 +00:00
auto taskctx = (qfv_taskctx_t *) ectx;
auto ctx = taskctx->ctx;
auto device = ctx->device;
auto dfunc = device->funcs;
auto dev = device->dev;
[vulkan] Move frames from vulkan_ctx to renderctx Part of the command buffer fix, but also a step towards cleaning up vulkan_ctx.
2023-06-22 07:44:05 +00:00
auto rctx = ctx->render_context;
auto frame = &rctx->frames.a[ctx->curFrame];
[vulkan] Add a step and task to create a framebuffer I don't like the current name (update_framebuffer), but if the referenced render pass doesn't have a framebuffer, one is created. The renderpass is referenced via the active renderpass of the named render step. Unfortunately, this has uncovered a bug in the setup of renderpass objects: main.deferred has output's renderpass, and main.deferred_cube and output have bogus renderpass objects.
2023-06-18 09:42:07 +00:00
dfunc->vkWaitForFences (dev, 1, &frame->fence, VK_TRUE, 2000000000);
[vulkan] Use per-swapchain images for output framebuffers Imageless framebuffers would probably be easier and cleaner, but this takes care of the validation error attempting to present the second frame (because rendering was being done to the first frame's swapchain image instead of the second frame's).
2023-06-21 05:47:19 +00:00
[vulkan] Use a command buffer pool manager Many thanks to Peter and Darian for clearing up my misunderstanding of how vkResetCommandPool works. The manager creates command buffers from the command pool on an as-needed basis (when the queue of available buffers is empty), and keeps track of those buffers in a queue. When the pool is reset, the queues (one each for primary and secondary command buffers) are reset such that the tracked buffers are available again.
2023-06-22 08:00:10 +00:00
QFV_CmdPoolManager_Reset (&frame->cmdpool);
[vulkan] Use per-swapchain images for output framebuffers Imageless framebuffers would probably be easier and cleaner, but this takes care of the validation error attempting to present the second frame (because rendering was being done to the first frame's swapchain image instead of the second frame's).
2023-06-21 05:47:19 +00:00
auto job = ctx->render_context->job;
[vulkan] Get the output step working for draw It leaks command buffers (due to a misunderstanding of vkResetCommandPool), but it seems 2d draw (sliced quads) is working nicely.
2023-06-21 14:31:08 +00:00
DARRAY_RESIZE (&job->commands, 0);
[vulkan] Add a step and task to create a framebuffer I don't like the current name (update_framebuffer), but if the referenced render pass doesn't have a framebuffer, one is created. The renderpass is referenced via the active renderpass of the named render step. Unfortunately, this has uncovered a bug in the setup of renderpass objects: main.deferred has output's renderpass, and main.deferred_cube and output have bogus renderpass objects.
2023-06-18 09:42:07 +00:00
}
[vulkan] Pass validation for the first frame The new render system now passes validation for the first frame (but no drawing is done by the various subsystems yet). Something is wrong with how swap chain semaphores are handled thus the second frame fails. Frame buffer attachments can now be defined externally, with "$swapchain" supported for now (in which case, the swap chain defines the size of the frame buffer). Also, render pass render areas and pipeline viewport and scissor rects are updated when necessary.
2023-06-20 06:18:58 +00:00
static void
[vulkan] Get window resize working again The biggest change was splitting up the job resources into per-render-pass resources, allowing individual render passes to reallocate their resources without affecting any others. After that, it was just getting translucency and capture working after a window resize.
2023-07-03 11:05:27 +00:00
renderpass_update_viewport_sissor (qfv_renderpass_t *rp,
const qfv_output_t *output)
[vulkan] Pass validation for the first frame The new render system now passes validation for the first frame (but no drawing is done by the various subsystems yet). Something is wrong with how swap chain semaphores are handled thus the second frame fails. Frame buffer attachments can now be defined externally, with "$swapchain" supported for now (in which case, the swap chain defines the size of the frame buffer). Also, render pass render areas and pipeline viewport and scissor rects are updated when necessary.
2023-06-20 06:18:58 +00:00
{
rp->beginInfo.renderArea.extent = output->extent;
for (uint32_t i = 0; i < rp->subpass_count; i++) {
auto sp = &rp->subpasses[i];
for (uint32_t j = 0; j < sp->pipeline_count; j++) {
auto pl = &sp->pipelines[j];
[vulkan] Correct depth and winding issues Quake data needs clockwise winding, and both min and max depth of 0 makes for some very strange results.
2023-06-22 15:50:27 +00:00
pl->viewport = (VkViewport) {
.width = output->extent.width,
.height = output->extent.height,
.minDepth = 0,
.maxDepth = 1,
};
[vulkan] Pass validation for the first frame The new render system now passes validation for the first frame (but no drawing is done by the various subsystems yet). Something is wrong with how swap chain semaphores are handled thus the second frame fails. Frame buffer attachments can now be defined externally, with "$swapchain" supported for now (in which case, the swap chain defines the size of the frame buffer). Also, render pass render areas and pipeline viewport and scissor rects are updated when necessary.
2023-06-20 06:18:58 +00:00
pl->scissor.extent = output->extent;
}
}
}
static void
update_viewport_scissor (qfv_render_t *render, const qfv_output_t *output)
{
for (uint32_t i = 0; i < render->num_renderpasses; i++) {
[vulkan] Get window resize working again The biggest change was splitting up the job resources into per-render-pass resources, allowing individual render passes to reallocate their resources without affecting any others. After that, it was just getting translucency and capture working after a window resize.
2023-07-03 11:05:27 +00:00
renderpass_update_viewport_sissor (&render->renderpasses[i], output);
[vulkan] Pass validation for the first frame The new render system now passes validation for the first frame (but no drawing is done by the various subsystems yet). Something is wrong with how swap chain semaphores are handled thus the second frame fails. Frame buffer attachments can now be defined externally, with "$swapchain" supported for now (in which case, the swap chain defines the size of the frame buffer). Also, render pass render areas and pipeline viewport and scissor rects are updated when necessary.
2023-06-20 06:18:58 +00:00
}
}
[vulkan] Add a step and task to create a framebuffer I don't like the current name (update_framebuffer), but if the referenced render pass doesn't have a framebuffer, one is created. The renderpass is referenced via the active renderpass of the named render step. Unfortunately, this has uncovered a bug in the setup of renderpass objects: main.deferred has output's renderpass, and main.deferred_cube and output have bogus renderpass objects.
2023-06-18 09:42:07 +00:00
static void
update_framebuffer (const exprval_t **params, exprval_t *result,
exprctx_t *ectx)
{
auto taskctx = (qfv_taskctx_t *) ectx;
auto ctx = taskctx->ctx;
[vulkan] Pass validation for the first frame The new render system now passes validation for the first frame (but no drawing is done by the various subsystems yet). Something is wrong with how swap chain semaphores are handled thus the second frame fails. Frame buffer attachments can now be defined externally, with "$swapchain" supported for now (in which case, the swap chain defines the size of the frame buffer). Also, render pass render areas and pipeline viewport and scissor rects are updated when necessary.
2023-06-20 06:18:58 +00:00
auto job = ctx->render_context->job;
auto step = QFV_GetStep (params[0], job);
[vulkan] Add a step and task to create a framebuffer I don't like the current name (update_framebuffer), but if the referenced render pass doesn't have a framebuffer, one is created. The renderpass is referenced via the active renderpass of the named render step. Unfortunately, this has uncovered a bug in the setup of renderpass objects: main.deferred has output's renderpass, and main.deferred_cube and output have bogus renderpass objects.
2023-06-18 09:42:07 +00:00
auto render = step->render;
auto rp = render->active;
[vulkan] Pass validation for the first frame The new render system now passes validation for the first frame (but no drawing is done by the various subsystems yet). Something is wrong with how swap chain semaphores are handled thus the second frame fails. Frame buffer attachments can now be defined externally, with "$swapchain" supported for now (in which case, the swap chain defines the size of the frame buffer). Also, render pass render areas and pipeline viewport and scissor rects are updated when necessary.
2023-06-20 06:18:58 +00:00
qfv_output_t output = {};
Vulkan_ConfigOutput (ctx, &output);
[vulkan] Delay main render resizes by 2s This makes window resizing a little more responsive (though it could be better yet (maybe, could be an X11 limitation)).
2023-07-03 14:38:57 +00:00
if ((output.extent.width != render->output.extent.width
|| output.extent.height != render->output.extent.height)
&& (Sys_LongTime () - ctx->render_context->size_time) > 2*1000*1000) {
[vulkan] Get window resize working again The biggest change was splitting up the job resources into per-render-pass resources, allowing individual render passes to reallocate their resources without affecting any others. After that, it was just getting translucency and capture working after a window resize.
2023-07-03 11:05:27 +00:00
QFV_DestroyFramebuffer (ctx, rp);
[vulkan] Pass validation for the first frame The new render system now passes validation for the first frame (but no drawing is done by the various subsystems yet). Something is wrong with how swap chain semaphores are handled thus the second frame fails. Frame buffer attachments can now be defined externally, with "$swapchain" supported for now (in which case, the swap chain defines the size of the frame buffer). Also, render pass render areas and pipeline viewport and scissor rects are updated when necessary.
2023-06-20 06:18:58 +00:00
update_viewport_scissor (render, &output);
[vulkan] Get window resize working again The biggest change was splitting up the job resources into per-render-pass resources, allowing individual render passes to reallocate their resources without affecting any others. After that, it was just getting translucency and capture working after a window resize.
2023-07-03 11:05:27 +00:00
render->output.extent = output.extent;
[vulkan] Pass validation for the first frame The new render system now passes validation for the first frame (but no drawing is done by the various subsystems yet). Something is wrong with how swap chain semaphores are handled thus the second frame fails. Frame buffer attachments can now be defined externally, with "$swapchain" supported for now (in which case, the swap chain defines the size of the frame buffer). Also, render pass render areas and pipeline viewport and scissor rects are updated when necessary.
2023-06-20 06:18:58 +00:00
}
[vulkan] Add a step and task to create a framebuffer I don't like the current name (update_framebuffer), but if the referenced render pass doesn't have a framebuffer, one is created. The renderpass is referenced via the active renderpass of the named render step. Unfortunately, this has uncovered a bug in the setup of renderpass objects: main.deferred has output's renderpass, and main.deferred_cube and output have bogus renderpass objects.
2023-06-18 09:42:07 +00:00
if (!rp->beginInfo.framebuffer) {
[vulkan] Get window resize working again The biggest change was splitting up the job resources into per-render-pass resources, allowing individual render passes to reallocate their resources without affecting any others. After that, it was just getting translucency and capture working after a window resize.
2023-07-03 11:05:27 +00:00
QFV_CreateFramebuffer (ctx, rp, render->output.extent);
[vulkan] Add a step and task to create a framebuffer I don't like the current name (update_framebuffer), but if the referenced render pass doesn't have a framebuffer, one is created. The renderpass is referenced via the active renderpass of the named render step. Unfortunately, this has uncovered a bug in the setup of renderpass objects: main.deferred has output's renderpass, and main.deferred_cube and output have bogus renderpass objects.
2023-06-18 09:42:07 +00:00
}
}
static exprfunc_t wait_on_fence_func[] = {
{ .func = wait_on_fence },
{}
};
static exprtype_t *update_framebuffer_params[] = {
&cexpr_string,
};
static exprfunc_t update_framebuffer_func[] = {
{ .func = update_framebuffer, .num_params = 1, update_framebuffer_params },
{}
};
static exprsym_t render_task_syms[] = {
{ "wait_on_fence", &cexpr_function, wait_on_fence_func },
{ "update_framebuffer", &cexpr_function, update_framebuffer_func },
{}
};
[vulkan] Create a render context This gets an empty (no tasks or pipelines connected) render context initialized and available for other subsystems to register their task functions. Nothing is using it yet, but the test parse of rp_main_def fails gracefully (needs those tasks).
2023-02-13 08:45:36 +00:00
void
QFV_Render_Init (vulkan_ctx_t *ctx)
{
qfv_renderctx_t *rctx = calloc (1, sizeof (*rctx));
ctx->render_context = rctx;
[vulkan] Delay main render resizes by 2s This makes window resizing a little more responsive (though it could be better yet (maybe, could be an X11 limitation)).
2023-07-03 14:38:57 +00:00
rctx->size_time = -1000*1000*1000;
[vulkan] Create a render context This gets an empty (no tasks or pipelines connected) render context initialized and available for other subsystems to register their task functions. Nothing is using it yet, but the test parse of rp_main_def fails gracefully (needs those tasks).
2023-02-13 08:45:36 +00:00
exprctx_t ectx = { .hashctx = &rctx->hashctx };
exprsym_t syms[] = { {} };
rctx->task_functions.symbols = syms;
cexpr_init_symtab (&rctx->task_functions, &ectx);
rctx->task_functions.symbols = 0;
[vulkan] Add a step and task to create a framebuffer I don't like the current name (update_framebuffer), but if the referenced render pass doesn't have a framebuffer, one is created. The renderpass is referenced via the active renderpass of the named render step. Unfortunately, this has uncovered a bug in the setup of renderpass objects: main.deferred has output's renderpass, and main.deferred_cube and output have bogus renderpass objects.
2023-06-18 09:42:07 +00:00
QFV_Render_AddTasks (ctx, render_task_syms);
[vulkan] Move frames from vulkan_ctx to renderctx Part of the command buffer fix, but also a step towards cleaning up vulkan_ctx.
2023-06-22 07:44:05 +00:00
auto device = ctx->device;
size_t frames = vulkan_frame_count;
DARRAY_INIT (&rctx->frames, frames);
DARRAY_RESIZE (&rctx->frames, frames);
for (size_t i = 0; i < rctx->frames.size; i++) {
auto frame = &rctx->frames.a[i];
frame->fence = QFV_CreateFence (device, 1);
frame->imageAvailableSemaphore = QFV_CreateSemaphore (device);
QFV_duSetObjectName (device, VK_OBJECT_TYPE_SEMAPHORE,
frame->imageAvailableSemaphore,
va (ctx->va_ctx, "sc image:%zd", i));
frame->renderDoneSemaphore = QFV_CreateSemaphore (device);
[vulkan] Name the managed command buffer pool Not that it mattered in the end, but it helps with debugging (found the bug while doing the edits).
2023-06-22 11:00:50 +00:00
QFV_CmdPoolManager_Init (&frame->cmdpool, device,
va (ctx->va_ctx, "render pool:%zd", i));
[vulkan] Move frames from vulkan_ctx to renderctx Part of the command buffer fix, but also a step towards cleaning up vulkan_ctx.
2023-06-22 07:44:05 +00:00
}
[vulkan] Attempt to load the render info spec It fails due to not supporting labeled arrays yet. I'm currently thinking about the design for vkgen.
2023-02-10 02:04:11 +00:00
}
[vulkan] Register task functions for the pipelines They're currently just stubs, but this gets the render info loading working without any errors. The next step is to connect up pipelines and create the image resources, then implementing the task functions will have meaning.
2023-02-13 15:55:22 +00:00
[vulkan] Create the render images and views And tear them down again on shutdown. The images and views are in a qfv_resource_t block, making their management much easier.
2023-02-19 03:53:02 +00:00
void
QFV_Render_Shutdown (vulkan_ctx_t *ctx)
{
[vulkan] Clean up the render objects on shutdown Not only does this quieten the validation layers, it ensures that all the object handles are named and where they need to be. Also fixes only one pipeline being created instead of the 15 or so.
2023-02-27 05:15:28 +00:00
qfv_device_t *device = ctx->device;
qfv_devfuncs_t *dfunc = device->funcs;
[vulkan] Create the render images and views And tear them down again on shutdown. The images and views are in a qfv_resource_t block, making their management much easier.
2023-02-19 03:53:02 +00:00
__auto_type rctx = ctx->render_context;
[vulkan] Implement most of the new job system There's still the actual job objects to create, but all the vulkan bits have been created and get destroyed on shutdown.
2023-03-22 10:32:49 +00:00
if (rctx->job) {
__auto_type job = rctx->job;
for (uint32_t i = 0; i < job->num_renderpasses; i++) {
dfunc->vkDestroyRenderPass (device->dev, job->renderpasses[i], 0);
[vulkan] Clean up the render objects on shutdown Not only does this quieten the validation layers, it ensures that all the object handles are named and where they need to be. Also fixes only one pipeline being created instead of the 15 or so.
2023-02-27 05:15:28 +00:00
}
[vulkan] Implement most of the new job system There's still the actual job objects to create, but all the vulkan bits have been created and get destroyed on shutdown.
2023-03-22 10:32:49 +00:00
for (uint32_t i = 0; i < job->num_pipelines; i++) {
dfunc->vkDestroyPipeline (device->dev, job->pipelines[i], 0);
}
for (uint32_t i = 0; i < job->num_layouts; i++) {
dfunc->vkDestroyPipelineLayout (device->dev, job->layouts[i], 0);
[vulkan] Create the render images and views And tear them down again on shutdown. The images and views are in a qfv_resource_t block, making their management much easier.
2023-02-19 03:53:02 +00:00
}
[vulkan] Destroy frame buffers on shutdown With this, the new render system, though not doing anything useful, at least passes validation.
2023-06-21 08:58:15 +00:00
for (uint32_t i = 0; i < job->num_steps; i++) {
if (job->steps[i].render) {
auto render = job->steps[i].render;
for (uint32_t j = 0; j < render->num_renderpasses; j++) {
[vulkan] Get window resize working again The biggest change was splitting up the job resources into per-render-pass resources, allowing individual render passes to reallocate their resources without affecting any others. After that, it was just getting translucency and capture working after a window resize.
2023-07-03 11:05:27 +00:00
auto rp = &render->renderpasses[j];
if (rp->resources && rp->resources->memory) {
QFV_DestroyResource (ctx->device, rp->resources);
}
free (rp->resources);
auto bi = &rp->beginInfo;
[vulkan] Destroy frame buffers on shutdown With this, the new render system, though not doing anything useful, at least passes validation.
2023-06-21 08:58:15 +00:00
if (bi->framebuffer) {
dfunc->vkDestroyFramebuffer (device->dev,
bi->framebuffer, 0);
}
}
}
}
[vulkan] Stub out the basic job execution Really, a bit more than stub as the basic code is there, but nothing works properly yet due to missing resources (especially descriptor sets and pools), and the frame buffer creation is still disabled.
2023-03-28 01:28:44 +00:00
DARRAY_CLEAR (&job->commands);
[vulkan] Create a descriptor set manager The manager allows recycling of descriptor sets and takes care of creating pools as needed.
2023-06-24 05:55:46 +00:00
for (uint32_t i = 0; i < job->num_dsmanagers; i++) {
QFV_DSManager_Destroy (job->dsmanager[i]);
}
[vulkan] Implement most of the new job system There's still the actual job objects to create, but all the vulkan bits have been created and get destroyed on shutdown.
2023-03-22 10:32:49 +00:00
free (rctx->job);
[vulkan] Create the render images and views And tear them down again on shutdown. The images and views are in a qfv_resource_t block, making their management much easier.
2023-02-19 03:53:02 +00:00
}
[vulkan] Move frames from vulkan_ctx to renderctx Part of the command buffer fix, but also a step towards cleaning up vulkan_ctx.
2023-06-22 07:44:05 +00:00
for (uint32_t i = 0; i < rctx->frames.size; i++) {
auto dev = device->dev;
auto df = dfunc;
auto frame = &rctx->frames.a[i];
df->vkDestroyFence (dev, frame->fence, 0);
df->vkDestroySemaphore (dev, frame->imageAvailableSemaphore, 0);
df->vkDestroySemaphore (dev, frame->renderDoneSemaphore, 0);
[vulkan] Use a command buffer pool manager Many thanks to Peter and Darian for clearing up my misunderstanding of how vkResetCommandPool works. The manager creates command buffers from the command pool on an as-needed basis (when the queue of available buffers is empty), and keeps track of those buffers in a queue. When the pool is reset, the queues (one each for primary and secondary command buffers) are reset such that the tracked buffers are available again.
2023-06-22 08:00:10 +00:00
QFV_CmdPoolManager_Shutdown (&frame->cmdpool);
[vulkan] Use per-swapchain images for output framebuffers Imageless framebuffers would probably be easier and cleaner, but this takes care of the validation error attempting to present the second frame (because rendering was being done to the first frame's swapchain image instead of the second frame's).
2023-06-21 05:47:19 +00:00
}
[vulkan] Move frames from vulkan_ctx to renderctx Part of the command buffer fix, but also a step towards cleaning up vulkan_ctx.
2023-06-22 07:44:05 +00:00
DARRAY_CLEAR (&rctx->frames);
[vulkan] Implement most of the new job system There's still the actual job objects to create, but all the vulkan bits have been created and get destroyed on shutdown.
2023-03-22 10:32:49 +00:00
if (rctx->jobinfo) {
__auto_type jinfo = rctx->jobinfo;
[vulkan] Create a descriptor set manager The manager allows recycling of descriptor sets and takes care of creating pools as needed.
2023-06-24 05:55:46 +00:00
for (uint32_t i = 0; i < jinfo->num_dslayouts; i++) {
__auto_type setLayout = jinfo->dslayouts[i].setLayout;
[vulkan] Clean up the render objects on shutdown Not only does this quieten the validation layers, it ensures that all the object handles are named and where they need to be. Also fixes only one pipeline being created instead of the 15 or so.
2023-02-27 05:15:28 +00:00
dfunc->vkDestroyDescriptorSetLayout (device->dev, setLayout, 0);
}
[vulkan] Implement most of the new job system There's still the actual job objects to create, but all the vulkan bits have been created and get destroyed on shutdown.
2023-03-22 10:32:49 +00:00
delete_memsuper (jinfo->memsuper);
[vulkan] Create the render images and views And tear them down again on shutdown. The images and views are in a qfv_resource_t block, making their management much easier.
2023-02-19 03:53:02 +00:00
}
if (rctx->task_functions.tab) {
Hash_DelTable (rctx->task_functions.tab);
}
[vulkan] Clean up the sampler config loading Samplers have no direct relation to render passes or pipelines, so should not necessarily be in the same config file. This makes all the old config files obsolete, and quite a bit of support code in vkparse.c.
2023-06-25 14:33:47 +00:00
if (rctx->samplerinfo) {
auto si = rctx->samplerinfo;
for (uint32_t i = 0; i < si->num_samplers; i++) {
auto sci = &si->samplers[i];
if (sci->sampler) {
dfunc->vkDestroySampler (device->dev, sci->sampler, 0);
}
}
}
[vulkan] Fix some memory leaks And deal with a shutdown order issue causing cvars to crash on shutdown (due to the hash links being freed too early).
2023-03-05 09:19:54 +00:00
Hash_DelContext (rctx->hashctx);
[vulkan] Add a very simple job window It shows the list of steps in the render job, but acts as something for testing.
2023-07-13 06:21:53 +00:00
QFV_Render_UI_Shutdown (ctx);
free (rctx);
[vulkan] Create the render images and views And tear them down again on shutdown. The images and views are in a qfv_resource_t block, making their management much easier.
2023-02-19 03:53:02 +00:00
}
[vulkan] Register task functions for the pipelines They're currently just stubs, but this gets the render info loading working without any errors. The next step is to connect up pipelines and create the image resources, then implementing the task functions will have meaning.
2023-02-13 15:55:22 +00:00
void
QFV_Render_AddTasks (vulkan_ctx_t *ctx, exprsym_t *task_syms)
{
__auto_type rctx = ctx->render_context;
exprctx_t ectx = { .hashctx = &rctx->hashctx };
for (exprsym_t *sym = task_syms; sym->name; sym++) {
Hash_Add (rctx->task_functions.tab, sym);
for (exprfunc_t *f = sym->value; f->func; f++) {
for (int i = 0; i < f->num_params; i++) {
exprenum_t *e = f->param_types[i]->data;
if (e && !e->symtab->tab) {
cexpr_init_symtab (e->symtab, &ectx);
}
}
}
}
}
[vulkan] Pass validation for the first frame The new render system now passes validation for the first frame (but no drawing is done by the various subsystems yet). Something is wrong with how swap chain semaphores are handled thus the second frame fails. Frame buffer attachments can now be defined externally, with "$swapchain" supported for now (in which case, the swap chain defines the size of the frame buffer). Also, render pass render areas and pipeline viewport and scissor rects are updated when necessary.
2023-06-20 06:18:58 +00:00
[vulkan] Destroy frame buffers on shutdown With this, the new render system, though not doing anything useful, at least passes validation.
2023-06-21 08:58:15 +00:00
qfv_step_t *
QFV_FindStep (const char *name, qfv_job_t *job)
{
for (uint32_t i = 0; i < job->num_steps; i++) {
auto step = &job->steps[i];
if (!strcmp (step->label.name, name)) {
return step;
}
}
return 0;
}
[vulkan] Pass validation for the first frame The new render system now passes validation for the first frame (but no drawing is done by the various subsystems yet). Something is wrong with how swap chain semaphores are handled thus the second frame fails. Frame buffer attachments can now be defined externally, with "$swapchain" supported for now (in which case, the swap chain defines the size of the frame buffer). Also, render pass render areas and pipeline viewport and scissor rects are updated when necessary.
2023-06-20 06:18:58 +00:00
qfv_step_t *
QFV_GetStep (const exprval_t *param, qfv_job_t *job)
{
// this is a little evil, but need to update the type after resolving
// the step name
auto stepref = (exprval_t *) param;
// cache the render step referenced, using the parameter type as a flag
// for whether the caching has been performed.
if (stepref->type == &cexpr_string) {
if (cexpr_string.size != cexpr_voidptr.size) {
Sys_Error ("string and voidptr incompatible sizes");
}
auto name = *(const char **)stepref->value;
stepref->type = &cexpr_voidptr;
[vulkan] Destroy frame buffers on shutdown With this, the new render system, though not doing anything useful, at least passes validation.
2023-06-21 08:58:15 +00:00
*(qfv_step_t **)stepref->value = QFV_FindStep (name, job);
[vulkan] Pass validation for the first frame The new render system now passes validation for the first frame (but no drawing is done by the various subsystems yet). Something is wrong with how swap chain semaphores are handled thus the second frame fails. Frame buffer attachments can now be defined externally, with "$swapchain" supported for now (in which case, the swap chain defines the size of the frame buffer). Also, render pass render areas and pipeline viewport and scissor rects are updated when necessary.
2023-06-20 06:18:58 +00:00
}
return *(qfv_step_t **)stepref->value;
}
[vulkan] Use the descriptor set manager This cleans up a lot of ugly code that I always thought was rather dumb.
2023-06-24 12:42:46 +00:00
qfv_dsmanager_t *
[vulkan] Clean up the sampler config loading Samplers have no direct relation to render passes or pipelines, so should not necessarily be in the same config file. This makes all the old config files obsolete, and quite a bit of support code in vkparse.c.
2023-06-25 14:33:47 +00:00
QFV_Render_DSManager (vulkan_ctx_t *ctx, const char *setName)
[vulkan] Use the descriptor set manager This cleans up a lot of ugly code that I always thought was rather dumb.
2023-06-24 12:42:46 +00:00
{
auto job = ctx->render_context->job;
for (uint32_t i = 0; i < job->num_dsmanagers; i++) {
auto ds = job->dsmanager[i];
if (!strcmp (ds->name, setName)) {
return ds;
}
}
return 0;
}
[vulkan] Clean up the sampler config loading Samplers have no direct relation to render passes or pipelines, so should not necessarily be in the same config file. This makes all the old config files obsolete, and quite a bit of support code in vkparse.c.
2023-06-25 14:33:47 +00:00
static void
create_sampler (vulkan_ctx_t *ctx, qfv_samplercreateinfo_t *sampler)
{
VkSamplerCreateInfo create = {
.sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO,
.flags = sampler->flags,
.magFilter = sampler->magFilter,
.minFilter = sampler->minFilter,
.mipmapMode = sampler->mipmapMode,
.addressModeU = sampler->addressModeU,
.addressModeV = sampler->addressModeV,
.addressModeW = sampler->addressModeW,
.mipLodBias = sampler->mipLodBias,
.anisotropyEnable = sampler->anisotropyEnable,
.maxAnisotropy = sampler->maxAnisotropy,
.compareEnable = sampler->compareEnable,
.compareOp = sampler->compareOp,
.minLod = sampler->minLod,
.maxLod = sampler->maxLod,
.borderColor = sampler->borderColor,
.unnormalizedCoordinates = sampler->unnormalizedCoordinates,
};
auto device = ctx->device;
auto dfunc = device->funcs;
dfunc->vkCreateSampler (device->dev, &create, 0, &sampler->sampler);
QFV_duSetObjectName (device, VK_OBJECT_TYPE_SAMPLER, sampler->sampler,
va (ctx->va_ctx, "sampler:%s", sampler->name));
}
VkSampler
QFV_Render_Sampler (vulkan_ctx_t *ctx, const char *name)
{
auto si = ctx->render_context->samplerinfo;
if (!si) {
return 0;
}
for (uint32_t i = 0; i < si->num_samplers; i++) {
auto sci = &si->samplers[i];
if (!strcmp (sci->name, name)) {
if (!sci->sampler) {
create_sampler (ctx, sci);
}
return sci->sampler;
}
}
printf ("sampler %s not found\n", name);
return 0;
}
Reference in a new issue Copy permalink