qf/quakeforge
0
0
Fork 0
mirror of https://git.code.sf.net/p/quake/quakeforge synced 2024-12-19 00:51:51 +00:00
Code Issues Projects Releases Packages Wiki Activity
quakeforge/libs/video/renderer/vulkan/vkparse.c

1499 lines
41 KiB
C
Raw Normal View History

[vulkan] Start work on scripted pipeline Nothing is actually done yet other than parsing the built-in property list to property list items (the actual parser is just a skeleton), but everything compiles
2020-07-16 06:42:49 +00:00
/*
vkparse.c
Parser for scripted vulkan structs
Copyright (C) 2020 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
[vulkan] Clean up a lot of unnecessary includes Too much copying of base files.
2022-03-30 06:54:07 +00:00
#include <string.h>
[vulkan] Start work on scripted pipeline Nothing is actually done yet other than parsing the built-in property list to property list items (the actual parser is just a skeleton), but everything compiles
2020-07-16 06:42:49 +00:00
[vulkan] Hook up the expression parser The pipeline parser still isn't hooked up yet as something isn't quite right, but it seems all the parsing works.
2020-12-21 09:38:31 +00:00
#include "QF/cmem.h"
[vulkan] Start work on scripted pipeline Nothing is actually done yet other than parsing the built-in property list to property list items (the actual parser is just a skeleton), but everything compiles
2020-07-16 06:42:49 +00:00
#include "QF/cvar.h"
[vulkan] Clean up some tangled dependencies Dependencies on vkparse.hinc were spreading through the code which I didn't want as that removes a lot of the automation from the automake files. This keeps all parser code internal to vkparse.c's scope, and any accesses required for enum and struct (not yet) definitions can be fetched by name.
2021-01-04 08:26:39 +00:00
#include "QF/hash.h"
[vulkan] Start work on scripted pipeline Nothing is actually done yet other than parsing the built-in property list to property list items (the actual parser is just a skeleton), but everything compiles
2020-07-16 06:42:49 +00:00
#include "QF/mathlib.h"
#include "QF/va.h"
[vulkan] Clean up a lot of unnecessary includes Too much copying of base files.
2022-03-30 06:54:07 +00:00
[vulkan] Name most resources This makes debugging with renderdoc and validation messages much easier (no more "what buffer is that?").
2021-01-31 10:58:55 +00:00
#include "QF/Vulkan/debug.h"
[vulkan] Start work on scripted pipeline Nothing is actually done yet other than parsing the built-in property list to property list items (the actual parser is just a skeleton), but everything compiles
2020-07-16 06:42:49 +00:00
#include "QF/Vulkan/device.h"
#include "QF/Vulkan/instance.h"
#include "QF/Vulkan/image.h"
[vulkan] Implement pipeline creation The prototypes for handle parsers needed to be changes because it turned out "single" was inappropriate for handles as "single" allocates memory for the parsed object, but handles must be written directly.
2021-01-05 14:42:30 +00:00
#include "QF/Vulkan/pipeline.h"
[vulkan] Break render pass parsing away from swapchain This allows a single render pass description to be used for both on-screen and off-screen targets. While Vulkan does allow a VkRenderPass to be used with any compatible frame buffer, and vkparse caches a VkRenderPass created from the same description, this allows the same description to be used for a compatible off-screen target without any dependence on the swapchain. However, there is a problem in the caching when it comes to targeting outputs with different formats.
2022-04-02 02:42:36 +00:00
#include "QF/Vulkan/renderpass.h"
[vulkan] Add support for custom parsers And provisionally parse shader stage defs.
2020-12-23 16:36:17 +00:00
#include "QF/Vulkan/shader.h"
[vulkan] Start work on scripted pipeline Nothing is actually done yet other than parsing the built-in property list to property list items (the actual parser is just a skeleton), but everything compiles
2020-07-16 06:42:49 +00:00
#include "vid_vulkan.h"
[vulkan] Clean up some tangled dependencies Dependencies on vkparse.hinc were spreading through the code which I didn't want as that removes a lot of the automation from the automake files. This keeps all parser code internal to vkparse.c's scope, and any accesses required for enum and struct (not yet) definitions can be fetched by name.
2021-01-04 08:26:39 +00:00
#define vkparse_internal
[vulkan] Start work on scripted pipeline Nothing is actually done yet other than parsing the built-in property list to property list items (the actual parser is just a skeleton), but everything compiles
2020-07-16 06:42:49 +00:00
#include "vkparse.h"
[vulkan] Clean up some tangled dependencies Dependencies on vkparse.hinc were spreading through the code which I didn't want as that removes a lot of the automation from the automake files. This keeps all parser code internal to vkparse.c's scope, and any accesses required for enum and struct (not yet) definitions can be fetched by name.
2021-01-04 08:26:39 +00:00
#undef vkparse_internal
[vulkan] Start work on scripted pipeline Nothing is actually done yet other than parsing the built-in property list to property list items (the actual parser is just a skeleton), but everything compiles
2020-07-16 06:42:49 +00:00
[vulkan] Break render pass parsing away from swapchain This allows a single render pass description to be used for both on-screen and off-screen targets. While Vulkan does allow a VkRenderPass to be used with any compatible frame buffer, and vkparse caches a VkRenderPass created from the same description, this allows the same description to be used for a compatible off-screen target without any dependence on the swapchain. However, there is a problem in the caching when it comes to targeting outputs with different formats.
2022-04-02 02:42:36 +00:00
typedef struct parseres_s {
const char *name;
plfield_t *field;
size_t offset;
} parseres_t;
typedef struct handleref_s {
char *name;
uint64_t handle;
} handleref_t;
[vulkan] Hook up the expression parser The pipeline parser still isn't hooked up yet as something isn't quite right, but it seems all the parsing works.
2020-12-21 09:38:31 +00:00
static void flag_or (const exprval_t *val1, const exprval_t *val2,
exprval_t *result, exprctx_t *ctx)
{
*(int *) (result->value) = *(int *) (val1->value) | *(int *) (val2->value);
}
static void flag_and (const exprval_t *val1, const exprval_t *val2,
exprval_t *result, exprctx_t *ctx)
{
*(int *) (result->value) = *(int *) (val1->value) & *(int *) (val2->value);
}
static void flag_cast_int (const exprval_t *val1, const exprval_t *val2,
exprval_t *result, exprctx_t *ctx)
{
// FIXME should check value is valid
*(int *) (result->value) = *(int *) (val2->value);
}
static void flag_not (const exprval_t *val, exprval_t *result, exprctx_t *ctx)
{
*(int *) (result->value) = ~(*(int *) (val->value));
}
binop_t flag_binops[] = {
{ '|', 0, 0, flag_or },
{ '&', 0, 0, flag_and },
{ '=', &cexpr_int, 0, flag_cast_int },
[util] Auto-cast plist string items The casting uses a recursive call to the expression parser, so the expressions are type-checked automatically.
2021-02-04 13:37:20 +00:00
{ '=', &cexpr_plitem, 0, cexpr_cast_plitem },
{}
};
binop_t enum_binops[] = {
{ '=', &cexpr_plitem, 0, cexpr_cast_plitem },
[vulkan] Hook up the expression parser The pipeline parser still isn't hooked up yet as something isn't quite right, but it seems all the parsing works.
2020-12-21 09:38:31 +00:00
{}
};
unop_t flag_unops[] = {
{ '~', 0, flag_not },
{}
};
[vulkan] Start work on scripted pipeline Nothing is actually done yet other than parsing the built-in property list to property list items (the actual parser is just a skeleton), but everything compiles
2020-07-16 06:42:49 +00:00
typedef struct parse_single_s {
[vulkan] Implement most of the parser This gets renderpass parsing almost working (not hooked up, though). The missing bits are support for expressions for flags (namely support for the | operator) and references (eg $swapchain.format). However, this shows that the basic concept for the parser is working.
2020-07-16 15:29:53 +00:00
pltype_t type;
size_t stride;
[vulkan] Start work on scripted pipeline Nothing is actually done yet other than parsing the built-in property list to property list items (the actual parser is just a skeleton), but everything compiles
2020-07-16 06:42:49 +00:00
plparser_t parser;
size_t value_offset;
} parse_single_t;
typedef struct parse_array_s {
[vulkan] Implement most of the parser This gets renderpass parsing almost working (not hooked up, though). The missing bits are support for expressions for flags (namely support for the | operator) and references (eg $swapchain.format). However, this shows that the basic concept for the parser is working.
2020-07-16 15:29:53 +00:00
pltype_t type;
size_t stride;
[vulkan] Start work on scripted pipeline Nothing is actually done yet other than parsing the built-in property list to property list items (the actual parser is just a skeleton), but everything compiles
2020-07-16 06:42:49 +00:00
plparser_t parser;
size_t value_offset;
[vulkan] Implement most of the parser This gets renderpass parsing almost working (not hooked up, though). The missing bits are support for expressions for flags (namely support for the | operator) and references (eg $swapchain.format). However, this shows that the basic concept for the parser is working.
2020-07-16 15:29:53 +00:00
size_t size_offset;
[vulkan] Start work on scripted pipeline Nothing is actually done yet other than parsing the built-in property list to property list items (the actual parser is just a skeleton), but everything compiles
2020-07-16 06:42:49 +00:00
} parse_array_t;
[vkgen] Add support for fixed arrays I want to support reading VkPhysicalDeviceLimits but it has some arrays. While I don't need to parse them (VkPhysicalDeviceLimits should be treated as read-only), I do need to be able to access them in property list expressions, and vkgen generates the cexpr type descriptors too. However, I will probably want to parse arrays some time in the future.
2021-12-04 01:08:27 +00:00
typedef struct parse_fixed_array_s {
pltype_t type;
size_t stride;
plparser_t parser;
size_t size;
} parse_fixed_array_t;
[vulkan] Add support for parsing binary data
2020-12-23 05:08:53 +00:00
typedef struct parse_data_s {
size_t value_offset;
size_t size_offset;
} parse_data_t;
[vulkan] Refactor vkgen struct generation The addition of data an then string support made keeping track of things in struct's writeTable a nightmare.
2020-12-23 13:13:50 +00:00
typedef struct parse_string_s {
size_t value_offset;
} parse_string_t;
[vulkan] Add support for custom parsers And provisionally parse shader stage defs.
2020-12-23 16:36:17 +00:00
typedef struct parse_custom_s {
int (*parse) (const plitem_t *item, void **data,
plitem_t *messages, parsectx_t *context);
size_t *offsets;
size_t num_offsets;
} parse_custom_t;
[vulkan] Support parsing numeric types
2020-12-24 00:58:27 +00:00
static int
parse_basic (const plfield_t *field, const plitem_t *item,
void *data, plitem_t *messages, void *context)
{
int ret = 1;
__auto_type etype = (exprtype_t *) field->data;
exprctx_t ectx = *((parsectx_t *) context)->ectx;
exprval_t result = { etype, data };
ectx.result = &result;
const char *valstr = PL_String (item);
[util] Make developer flag names easier to manage They're now an enum, and the flag part of the name is all lowercase, but now the flag definitions and names list will never get out of sync.
2021-03-29 10:58:00 +00:00
//Sys_MaskPrintf (SYS_vulkan_parse, "parse_basic: %s %zd %d %p %p: %s\n",
[vulkan] Suppress all the debug output silence is golden
2021-03-23 04:04:22 +00:00
// field->name, field->offset, field->type, field->parser,
// field->data, valstr);
[vulkan] Support parsing numeric types
2020-12-24 00:58:27 +00:00
if (strcmp (valstr, "VK_SUBPASS_EXTERNAL") == 0) {
//FIXME handle subpass in a separate parser?
*(uint32_t *) data = VK_SUBPASS_EXTERNAL;
} else {
ret = !cexpr_eval_string (valstr, &ectx);
[vulkan] Implement pipeline creation The prototypes for handle parsers needed to be changes because it turned out "single" was inappropriate for handles as "single" allocates memory for the parsed object, but handles must be written directly.
2021-01-05 14:42:30 +00:00
if (!ret) {
PL_Message (messages, item, "error parsing %s: %s",
field->name, valstr);
}
[vulkan] Support parsing numeric types
2020-12-24 00:58:27 +00:00
}
[util] Make developer flag names easier to manage They're now an enum, and the flag part of the name is all lowercase, but now the flag definitions and names list will never get out of sync.
2021-03-29 10:58:00 +00:00
//Sys_MaskPrintf (SYS_vulkan_parse, " %x\n", *(uint32_t *)data);
[vulkan] Support parsing numeric types
2020-12-24 00:58:27 +00:00
return ret;
}
[vulkan] Add support for custom parsers And provisionally parse shader stage defs.
2020-12-23 16:36:17 +00:00
static int
parse_uint32_t (const plfield_t *field, const plitem_t *item,
void *data, plitem_t *messages, void *context)
[vulkan] Start work on scripted pipeline Nothing is actually done yet other than parsing the built-in property list to property list items (the actual parser is just a skeleton), but everything compiles
2020-07-16 06:42:49 +00:00
{
[vulkan] Implement most of the parser This gets renderpass parsing almost working (not hooked up, though). The missing bits are support for expressions for flags (namely support for the | operator) and references (eg $swapchain.format). However, this shows that the basic concept for the parser is working.
2020-07-16 15:29:53 +00:00
int ret = 1;
[vulkan] Add a comment about using size_t Due to wanting to access array sizes when parsing uint32_t type values, parse_uint32_t needs to handle size_t values even though it throws out any excess bits.
2021-02-17 04:32:04 +00:00
// use size_t (and cexpr_size_t) for val so references to array sizes
// can be used
[vulkan] Use a size_t temp to parse uint32 values Needed for swapbuffer frame count
2021-01-10 06:29:47 +00:00
size_t val = 0;
exprval_t result = { &cexpr_size_t, &val };
[vulkan] Add a comment about using size_t Due to wanting to access array sizes when parsing uint32_t type values, parse_uint32_t needs to handle size_t values even though it throws out any excess bits.
2021-02-17 04:32:04 +00:00
exprctx_t ectx = *((parsectx_t *) context)->ectx;
[vulkan] Support parsing numeric types
2020-12-24 00:58:27 +00:00
ectx.result = &result;
[vulkan] Implement most of the parser This gets renderpass parsing almost working (not hooked up, though). The missing bits are support for expressions for flags (namely support for the | operator) and references (eg $swapchain.format). However, this shows that the basic concept for the parser is working.
2020-07-16 15:29:53 +00:00
const char *valstr = PL_String (item);
[util] Make developer flag names easier to manage They're now an enum, and the flag part of the name is all lowercase, but now the flag definitions and names list will never get out of sync.
2021-03-29 10:58:00 +00:00
//Sys_MaskPrintf (SYS_vulkan_parse, "parse_uint32_t: %s %zd %d %p %p: %s\n",
[vulkan] Suppress all the debug output silence is golden
2021-03-23 04:04:22 +00:00
// field->name, field->offset, field->type, field->parser,
// field->data, valstr);
[vulkan] Implement most of the parser This gets renderpass parsing almost working (not hooked up, though). The missing bits are support for expressions for flags (namely support for the | operator) and references (eg $swapchain.format). However, this shows that the basic concept for the parser is working.
2020-07-16 15:29:53 +00:00
if (strcmp (valstr, "VK_SUBPASS_EXTERNAL") == 0) {
[vulkan] Support parsing numeric types
2020-12-24 00:58:27 +00:00
//FIXME handle subpass in a separate parser?
[vulkan] Implement most of the parser This gets renderpass parsing almost working (not hooked up, though). The missing bits are support for expressions for flags (namely support for the | operator) and references (eg $swapchain.format). However, this shows that the basic concept for the parser is working.
2020-07-16 15:29:53 +00:00
*(uint32_t *) data = VK_SUBPASS_EXTERNAL;
} else {
[util] Make developer flag names easier to manage They're now an enum, and the flag part of the name is all lowercase, but now the flag definitions and names list will never get out of sync.
2021-03-29 10:58:00 +00:00
//Sys_MaskPrintf (SYS_vulkan_parse,
[vulkan] Suppress all the debug output silence is golden
2021-03-23 04:04:22 +00:00
// "parse_uint32_t: %s %zd %d %p %p %s\n",
// field->name, field->offset, field->type, field->parser,
// field->data, valstr);
[vulkan] Support parsing numeric types
2020-12-24 00:58:27 +00:00
ret = !cexpr_eval_string (valstr, &ectx);
[vulkan] Use a size_t temp to parse uint32 values Needed for swapbuffer frame count
2021-01-10 06:29:47 +00:00
if (!ret) {
PL_Message (messages, item, "error parsing %s: %s",
field->name, valstr);
}
*(uint32_t *) data = val;
[util] Make developer flag names easier to manage They're now an enum, and the flag part of the name is all lowercase, but now the flag definitions and names list will never get out of sync.
2021-03-29 10:58:00 +00:00
//Sys_MaskPrintf (SYS_vulkan_parse, " %d\n", *(uint32_t *)data);
[vulkan] Implement most of the parser This gets renderpass parsing almost working (not hooked up, though). The missing bits are support for expressions for flags (namely support for the | operator) and references (eg $swapchain.format). However, this shows that the basic concept for the parser is working.
2020-07-16 15:29:53 +00:00
}
return ret;
[vulkan] Start work on scripted pipeline Nothing is actually done yet other than parsing the built-in property list to property list items (the actual parser is just a skeleton), but everything compiles
2020-07-16 06:42:49 +00:00
}
[vulkan] Add support for custom parsers And provisionally parse shader stage defs.
2020-12-23 16:36:17 +00:00
static int
parse_enum (const plfield_t *field, const plitem_t *item,
void *data, plitem_t *messages, void *context)
[vulkan] Start work on scripted pipeline Nothing is actually done yet other than parsing the built-in property list to property list items (the actual parser is just a skeleton), but everything compiles
2020-07-16 06:42:49 +00:00
{
[vulkan] Implement most of the parser This gets renderpass parsing almost working (not hooked up, though). The missing bits are support for expressions for flags (namely support for the | operator) and references (eg $swapchain.format). However, this shows that the basic concept for the parser is working.
2020-07-16 15:29:53 +00:00
int ret = 1;
[vulkan] Hook up the expression parser The pipeline parser still isn't hooked up yet as something isn't quite right, but it seems all the parsing works.
2020-12-21 09:38:31 +00:00
__auto_type enm = (exprenum_t *) field->data;
[vulkan] Add support for custom parsers And provisionally parse shader stage defs.
2020-12-23 16:36:17 +00:00
exprctx_t ectx = *((parsectx_t *)context)->ectx;
[vulkan] Hook up the expression parser The pipeline parser still isn't hooked up yet as something isn't quite right, but it seems all the parsing works.
2020-12-21 09:38:31 +00:00
exprval_t result = { enm->type, data };
[vulkan] Connect up the cexpr library This will make property list expressions easier to work with. The library is rather limited right now (trig, dot, min/max/bound) but even just min adds a lot of functionality.
2021-12-04 05:09:57 +00:00
ectx.parent = ((parsectx_t *)context)->ectx;
[vulkan] Hook up the expression parser The pipeline parser still isn't hooked up yet as something isn't quite right, but it seems all the parsing works.
2020-12-21 09:38:31 +00:00
ectx.symtab = enm->symtab;
ectx.result = &result;
[vulkan] Implement most of the parser This gets renderpass parsing almost working (not hooked up, though). The missing bits are support for expressions for flags (namely support for the | operator) and references (eg $swapchain.format). However, this shows that the basic concept for the parser is working.
2020-07-16 15:29:53 +00:00
const char *valstr = PL_String (item);
[util] Make developer flag names easier to manage They're now an enum, and the flag part of the name is all lowercase, but now the flag definitions and names list will never get out of sync.
2021-03-29 10:58:00 +00:00
//Sys_MaskPrintf (SYS_vulkan_parse, "parse_enum: %s %zd %d %p %p %s\n",
[vulkan] Suppress all the debug output silence is golden
2021-03-23 04:04:22 +00:00
// field->name, field->offset, field->type, field->parser,
// field->data, valstr);
[vulkan] Hook up the expression parser The pipeline parser still isn't hooked up yet as something isn't quite right, but it seems all the parsing works.
2020-12-21 09:38:31 +00:00
ret = !cexpr_parse_enum (enm, valstr, &ectx, data);
[vulkan] Generate code for resource nodes This makes it easy to add resource nodes defining contextually named resources. It is already used for shaders, set layouts, and pipeline layouts.
2021-01-05 05:15:35 +00:00
if (!ret) {
PL_Message (messages, item, "error parsing enum: %s", valstr);
}
[util] Make developer flag names easier to manage They're now an enum, and the flag part of the name is all lowercase, but now the flag definitions and names list will never get out of sync.
2021-03-29 10:58:00 +00:00
//Sys_MaskPrintf (SYS_vulkan_parse, " %d\n", *(int *)data);
[vulkan] Implement most of the parser This gets renderpass parsing almost working (not hooked up, though). The missing bits are support for expressions for flags (namely support for the | operator) and references (eg $swapchain.format). However, this shows that the basic concept for the parser is working.
2020-07-16 15:29:53 +00:00
return ret;
[vulkan] Start work on scripted pipeline Nothing is actually done yet other than parsing the built-in property list to property list items (the actual parser is just a skeleton), but everything compiles
2020-07-16 06:42:49 +00:00
}
[vulkan] Allow all struct objects to be referenced
2021-02-14 02:20:54 +00:00
static const plitem_t *
parse_reference (const plitem_t *item, const char *type, plitem_t *messages,
parsectx_t *pctx)
{
exprctx_t ectx = *pctx->ectx;
plitem_t *refItem = 0;
exprval_t result = { &cexpr_plitem, &refItem };
ectx.result = &result;
const char *name = PL_String (item);
if (cexpr_eval_string (name, &ectx)) {
[build] Add -Wformat-non-literal option While this caused some trouble for pr_strings and configurable strftime (evil hacks abound), it's the result of discovering an ancient (from maybe as early as 2004, definitely before 2012) bug in qwaq's printing that somehow got past months of trial-by-fire testing (origin understood thanks to the warning finding it).
2021-03-29 08:27:06 +00:00
PL_Message (messages, item, "not a %s reference", type);
[vulkan] Allow all struct objects to be referenced
2021-02-14 02:20:54 +00:00
return 0;
}
return refItem;
}
Fix a pile of leaks and uninit errors Still "some" more to go: a pile to do with transforms and temporary entities, and a nasty one with host_cbuf. There's also all the static block-alloc lists :/
2021-03-21 10:56:17 +00:00
static void *
vkparse_alloc (void *context, size_t size)
{
parsectx_t *pctx = context;
return cmemalloc (pctx->ectx->memsuper, size);
}
[vulkan] Add support for custom parsers And provisionally parse shader stage defs.
2020-12-23 16:36:17 +00:00
static int
parse_single (const plfield_t *field, const plitem_t *item,
void *data, plitem_t *messages, void *context)
[vulkan] Start work on scripted pipeline Nothing is actually done yet other than parsing the built-in property list to property list items (the actual parser is just a skeleton), but everything compiles
2020-07-16 06:42:49 +00:00
{
[vulkan] Implement most of the parser This gets renderpass parsing almost working (not hooked up, though). The missing bits are support for expressions for flags (namely support for the | operator) and references (eg $swapchain.format). However, this shows that the basic concept for the parser is working.
2020-07-16 15:29:53 +00:00
__auto_type single = (parse_single_t *) field->data;
void *flddata = (byte *)data + single->value_offset;
[util] Make developer flag names easier to manage They're now an enum, and the flag part of the name is all lowercase, but now the flag definitions and names list will never get out of sync.
2021-03-29 10:58:00 +00:00
//Sys_MaskPrintf (SYS_vulkan_parse, "parse_single: %s %zd %d %p %p\n",
[vulkan] Suppress all the debug output silence is golden
2021-03-23 04:04:22 +00:00
// field->name, field->offset,
// field->type, field->parser, field->data);
[vulkan] Implement most of the parser This gets renderpass parsing almost working (not hooked up, though). The missing bits are support for expressions for flags (namely support for the | operator) and references (eg $swapchain.format). However, this shows that the basic concept for the parser is working.
2020-07-16 15:29:53 +00:00
[vulkan] Implement pipeline creation The prototypes for handle parsers needed to be changes because it turned out "single" was inappropriate for handles as "single" allocates memory for the parsed object, but handles must be written directly.
2021-01-05 14:42:30 +00:00
if (!PL_CheckType (single->type, PL_Type (item))) {
PL_TypeMismatch (messages, item, field->name, single->type,
PL_Type (item));
[vulkan] Implement most of the parser This gets renderpass parsing almost working (not hooked up, though). The missing bits are support for expressions for flags (namely support for the | operator) and references (eg $swapchain.format). However, this shows that the basic concept for the parser is working.
2020-07-16 15:29:53 +00:00
return 0;
}
plfield_t f = { 0, 0, single->type, single->parser, 0 };
Fix a pile of leaks and uninit errors Still "some" more to go: a pile to do with transforms and temporary entities, and a nasty one with host_cbuf. There's also all the static block-alloc lists :/
2021-03-21 10:56:17 +00:00
void *value = vkparse_alloc (context, single->stride);
memset (value, 0, single->stride);
[vulkan] Hook up the expression parser The pipeline parser still isn't hooked up yet as something isn't quite right, but it seems all the parsing works.
2020-12-21 09:38:31 +00:00
if (!single->parser (&f, item, value, messages, context)) {
[vulkan] Implement most of the parser This gets renderpass parsing almost working (not hooked up, though). The missing bits are support for expressions for flags (namely support for the | operator) and references (eg $swapchain.format). However, this shows that the basic concept for the parser is working.
2020-07-16 15:29:53 +00:00
return 0;
}
*(void **) flddata = value;
return 1;
[vulkan] Start work on scripted pipeline Nothing is actually done yet other than parsing the built-in property list to property list items (the actual parser is just a skeleton), but everything compiles
2020-07-16 06:42:49 +00:00
}
[vulkan] Add support for custom parsers And provisionally parse shader stage defs.
2020-12-23 16:36:17 +00:00
static int
parse_array (const plfield_t *field, const plitem_t *item,
void *data, plitem_t *messages, void *context)
[vulkan] Start work on scripted pipeline Nothing is actually done yet other than parsing the built-in property list to property list items (the actual parser is just a skeleton), but everything compiles
2020-07-16 06:42:49 +00:00
{
[vulkan] Implement most of the parser This gets renderpass parsing almost working (not hooked up, though). The missing bits are support for expressions for flags (namely support for the | operator) and references (eg $swapchain.format). However, this shows that the basic concept for the parser is working.
2020-07-16 15:29:53 +00:00
__auto_type array = (parse_array_t *) field->data;
__auto_type value = (void **) ((byte *)data + array->value_offset);
__auto_type size = (uint32_t *) ((byte *)data + array->size_offset);
plelement_t element = {
array->type,
array->stride,
Fix a pile of leaks and uninit errors Still "some" more to go: a pile to do with transforms and temporary entities, and a nasty one with host_cbuf. There's also all the static block-alloc lists :/
2021-03-21 10:56:17 +00:00
vkparse_alloc,
[vulkan] Implement most of the parser This gets renderpass parsing almost working (not hooked up, though). The missing bits are support for expressions for flags (namely support for the | operator) and references (eg $swapchain.format). However, this shows that the basic concept for the parser is working.
2020-07-16 15:29:53 +00:00
array->parser,
0,
};
plfield_t f = { 0, 0, 0, 0, &element };
typedef struct arr_s DARRAY_TYPE(byte) arr_t;
arr_t *arr;
[util] Make developer flag names easier to manage They're now an enum, and the flag part of the name is all lowercase, but now the flag definitions and names list will never get out of sync.
2021-03-29 10:58:00 +00:00
//Sys_MaskPrintf (SYS_vulkan_parse, "parse_array: %s %zd %d %p %p %p\n",
[vulkan] Suppress all the debug output silence is golden
2021-03-23 04:04:22 +00:00
// field->name, field->offset, field->type, field->parser,
// field->data, data);
[util] Make developer flag names easier to manage They're now an enum, and the flag part of the name is all lowercase, but now the flag definitions and names list will never get out of sync.
2021-03-29 10:58:00 +00:00
//Sys_MaskPrintf (SYS_vulkan_parse, " %d %zd %p %zd %zd\n", array->type,
[vulkan] Suppress all the debug output silence is golden
2021-03-23 04:04:22 +00:00
// array->stride, array->parser, array->value_offset,
// array->size_offset);
[vulkan] Hook up the expression parser The pipeline parser still isn't hooked up yet as something isn't quite right, but it seems all the parsing works.
2020-12-21 09:38:31 +00:00
if (!PL_ParseArray (&f, item, &arr, messages, context)) {
[vulkan] Implement most of the parser This gets renderpass parsing almost working (not hooked up, though). The missing bits are support for expressions for flags (namely support for the | operator) and references (eg $swapchain.format). However, this shows that the basic concept for the parser is working.
2020-07-16 15:29:53 +00:00
return 0;
}
Fix a pile of leaks and uninit errors Still "some" more to go: a pile to do with transforms and temporary entities, and a nasty one with host_cbuf. There's also all the static block-alloc lists :/
2021-03-21 10:56:17 +00:00
*value = vkparse_alloc (context, array->stride * arr->size);
[vulkan] Implement most of the parser This gets renderpass parsing almost working (not hooked up, though). The missing bits are support for expressions for flags (namely support for the | operator) and references (eg $swapchain.format). However, this shows that the basic concept for the parser is working.
2020-07-16 15:29:53 +00:00
memcpy (*value, arr->a, array->stride * arr->size);
[vulkan] Fix array parsing size error The size was not getting written if it was the first value in the structure.
2021-01-23 11:40:11 +00:00
if ((void *) size >= data) {
[vulkan] Implement most of the parser This gets renderpass parsing almost working (not hooked up, though). The missing bits are support for expressions for flags (namely support for the | operator) and references (eg $swapchain.format). However, this shows that the basic concept for the parser is working.
2020-07-16 15:29:53 +00:00
*size = arr->size;
}
return 1;
[vulkan] Start work on scripted pipeline Nothing is actually done yet other than parsing the built-in property list to property list items (the actual parser is just a skeleton), but everything compiles
2020-07-16 06:42:49 +00:00
}
[vkgen] Add support for fixed arrays I want to support reading VkPhysicalDeviceLimits but it has some arrays. While I don't need to parse them (VkPhysicalDeviceLimits should be treated as read-only), I do need to be able to access them in property list expressions, and vkgen generates the cexpr type descriptors too. However, I will probably want to parse arrays some time in the future.
2021-12-04 01:08:27 +00:00
static int
parse_fixed_array (const plfield_t *field, const plitem_t *item,
void *data, plitem_t *messages, void *context)
{
__auto_type array = (parse_fixed_array_t *) field->data;
plelement_t element = {
array->type,
array->stride,
vkparse_alloc,
array->parser,
0,
};
plfield_t f = { 0, 0, 0, 0, &element };
typedef struct arr_s DARRAY_TYPE(byte) arr_t;
arr_t *arr;
if (!PL_ParseArray (&f, item, &arr, messages, context)) {
return 0;
}
memset (data, 0, array->stride * array->size);
size_t size = min (array->size, arr->size);
memcpy (data, arr->a, array->stride * size);
return 1;
}
[vulkan] Add support for custom parsers And provisionally parse shader stage defs.
2020-12-23 16:36:17 +00:00
static int
parse_string (const plfield_t *field, const plitem_t *item,
void *data, plitem_t *messages, void *context)
[vulkan] Refactor vkgen struct generation The addition of data an then string support made keeping track of things in struct's writeTable a nightmare.
2020-12-23 13:13:50 +00:00
{
__auto_type string = (parse_string_t *) field->data;
__auto_type value = (char **) ((byte *)data + string->value_offset);
[vulkan] Implement pipeline creation The prototypes for handle parsers needed to be changes because it turned out "single" was inappropriate for handles as "single" allocates memory for the parsed object, but handles must be written directly.
2021-01-05 14:42:30 +00:00
const char *str = PL_String (item);
[vulkan] Refactor vkgen struct generation The addition of data an then string support made keeping track of things in struct's writeTable a nightmare.
2020-12-23 13:13:50 +00:00
[util] Make developer flag names easier to manage They're now an enum, and the flag part of the name is all lowercase, but now the flag definitions and names list will never get out of sync.
2021-03-29 10:58:00 +00:00
//Sys_MaskPrintf (SYS_vulkan_parse, "parse_string: %s %zd %d %p %p %p\n",
[vulkan] Suppress all the debug output silence is golden
2021-03-23 04:04:22 +00:00
// field->name, field->offset, field->type, field->parser,
// field->data, data);
[util] Make developer flag names easier to manage They're now an enum, and the flag part of the name is all lowercase, but now the flag definitions and names list will never get out of sync.
2021-03-29 10:58:00 +00:00
//Sys_MaskPrintf (SYS_vulkan_parse, " %zd\n", string->value_offset);
//Sys_MaskPrintf (SYS_vulkan_parse, " %s\n", str);
[vulkan] Refactor vkgen struct generation The addition of data an then string support made keeping track of things in struct's writeTable a nightmare.
2020-12-23 13:13:50 +00:00
Fix a pile of leaks and uninit errors Still "some" more to go: a pile to do with transforms and temporary entities, and a nasty one with host_cbuf. There's also all the static block-alloc lists :/
2021-03-21 10:56:17 +00:00
size_t len = strlen (str) + 1;
*value = vkparse_alloc (context, len);
memcpy (*value, str, len);
[vulkan] Refactor vkgen struct generation The addition of data an then string support made keeping track of things in struct's writeTable a nightmare.
2020-12-23 13:13:50 +00:00
return 1;
}
[vulkan] Add support for custom parsers And provisionally parse shader stage defs.
2020-12-23 16:36:17 +00:00
static int
parse_custom (const plfield_t *field, const plitem_t *item,
void *data, plitem_t *messages, void *context)
{
__auto_type custom = (parse_custom_t *) field->data;
void **offsets = alloca (custom->num_offsets * sizeof (void *));
for (size_t i = 0; i < custom->num_offsets; i++) {
offsets[i] = data + custom->offsets[i];
}
return custom->parse (item, offsets, messages, context);
}
[vkparse] Add support for inheriting objects It simply parses the referenced plist dictionary (via @inherit = plist.path;) into the current data block, then allows the data to be overwritten by the current plist dictionary. This may be a bit iffy for any allocated resources, so some care must be taken, but it seems to work nicely.
2022-04-03 02:11:28 +00:00
static int
parse_inherit (const plfield_t *field, const plitem_t *item,
void *data, plitem_t *messages, void *context)
{
exprctx_t ectx = *((parsectx_t *)context)->ectx;
plitem_t *inheritItem = 0;
exprval_t result = { &cexpr_plitem, &inheritItem };
ectx.result = &result;
const char *inheritstr = PL_String (item);
Sys_MaskPrintf (SYS_vulkan_parse, "parse_inherit: %s\n", inheritstr);
int ret = !cexpr_eval_string (inheritstr, &ectx);
if (ret) {
ret = PL_ParseStruct (field->data, inheritItem, data, messages,
context);
}
return ret;
}
[vulkan] Implement pipeline layout creation It seems to work when parsing the layouts. They can be created in-line (in theory) or in a "setLayouts" node and then referenced by name.
2021-01-04 08:36:11 +00:00
static int
parse_RGBA (const plitem_t *item, void **data,
plitem_t *messages, parsectx_t *context)
{
int ret = 1;
exprctx_t ectx = *context->ectx;
exprval_t result = { &cexpr_vector, data[0] };
ectx.result = &result;
const char *valstr = PL_String (item);
[util] Make developer flag names easier to manage They're now an enum, and the flag part of the name is all lowercase, but now the flag definitions and names list will never get out of sync.
2021-03-29 10:58:00 +00:00
Sys_MaskPrintf (SYS_vulkan_parse, "parse_RGBA: %s\n", valstr);
[vulkan] Implement pipeline layout creation It seems to work when parsing the layouts. They can be created in-line (in theory) or in a "setLayouts" node and then referenced by name.
2021-01-04 08:36:11 +00:00
ret = !cexpr_eval_string (valstr, &ectx);
[util] Make developer flag names easier to manage They're now an enum, and the flag part of the name is all lowercase, but now the flag definitions and names list will never get out of sync.
2021-03-29 10:58:00 +00:00
Sys_MaskPrintf (SYS_vulkan_parse, " "VEC4F_FMT"\n",
[vulkan] Suppress all the debug output silence is golden
2021-03-23 04:04:22 +00:00
VEC4_EXP (*(vec4f_t *)data[0]));
[vulkan] Implement pipeline layout creation It seems to work when parsing the layouts. They can be created in-line (in theory) or in a "setLayouts" node and then referenced by name.
2021-01-04 08:36:11 +00:00
return ret;
}
[vulkan] Clean up some tangled dependencies Dependencies on vkparse.hinc were spreading through the code which I didn't want as that removes a lot of the automation from the automake files. This keeps all parser code internal to vkparse.c's scope, and any accesses required for enum and struct (not yet) definitions can be fetched by name.
2021-01-04 08:26:39 +00:00
[vulkan] Take care of the duplicate handles
2021-02-04 11:40:28 +00:00
uint64_t
QFV_GetHandle (hashtab_t *tab, const char *name)
{
handleref_t *hr = Hash_Find (tab, name);
if (hr) {
return hr->handle;
}
return 0;
}
void
QFV_AddHandle (hashtab_t *tab, const char *name, uint64_t handle)
[vulkan] Rework pipeline parsing for better reuse It's not entirely there yet, but the basics are working. Work is still needed for avoiding duplication of objects (different threads will have different contexts and thus different tables, so necessary per-thread duplication should not become a problem) and general access to arbitrary fields (mostly just parsing the strings)
2021-02-04 08:03:49 +00:00
{
handleref_t *hr = malloc (sizeof (handleref_t));
hr->name = strdup (name);
hr->handle = handle;
Hash_Add (tab, hr);
}
[vulkan] Clean up misuse of va for vulkan handles The built up "path" name of the handle resource was not always surviving the intervening call to cexpr_eval_string (in particular, when other handles were created in the process of creating a handle). Rather than simply increase the number of va buffers (where would it end?), just regenerate the path when adding the new handle. It's probably quick enough, and the code is not usually not on a critical path.
2021-04-22 10:47:42 +00:00
static const char *
resource_path (vulkan_ctx_t *ctx, const char *prefix, const char *name)
{
if (name[0] != '$') {
if (prefix) {
name = va (ctx->va_ctx, "$"QFV_PROPERTIES".%s.%s", prefix, name);
} else {
name = va (ctx->va_ctx, "$"QFV_PROPERTIES".%s", name);
}
}
return name;
}
[vulkan] Parse clear values And get the render pass working in general. Note that this is only the render pass and frame buffers: actual commands still have problems.
2021-02-23 05:37:48 +00:00
static int
parse_VkRenderPass (const plitem_t *item, void **data,
plitem_t *messages, parsectx_t *context)
{
__auto_type handle = (VkRenderPass *) data[0];
int ret = 1;
parsectx_t *pctx = context;
exprctx_t ectx = *pctx->ectx;
vulkan_ctx_t *ctx = pctx->vctx;
const char *name = PL_String (item);
[vulkan] Clean up misuse of va for vulkan handles The built up "path" name of the handle resource was not always surviving the intervening call to cexpr_eval_string (in particular, when other handles were created in the process of creating a handle). Rather than simply increase the number of va buffers (where would it end?), just regenerate the path when adding the new handle. It's probably quick enough, and the code is not usually not on a critical path.
2021-04-22 10:47:42 +00:00
const char *path = resource_path (ctx, 0, name);
Sys_MaskPrintf (SYS_vulkan_parse, "parse_VkRenderPass: %s\n", path);
[vulkan] Parse clear values And get the render pass working in general. Note that this is only the render pass and frame buffers: actual commands still have problems.
2021-02-23 05:37:48 +00:00
[vulkan] Clean up misuse of va for vulkan handles The built up "path" name of the handle resource was not always surviving the intervening call to cexpr_eval_string (in particular, when other handles were created in the process of creating a handle). Rather than simply increase the number of va buffers (where would it end?), just regenerate the path when adding the new handle. It's probably quick enough, and the code is not usually not on a critical path.
2021-04-22 10:47:42 +00:00
*handle = (VkRenderPass) QFV_GetHandle (ctx->renderpasses, path);
[vulkan] Parse clear values And get the render pass working in general. Note that this is only the render pass and frame buffers: actual commands still have problems.
2021-02-23 05:37:48 +00:00
if (*handle) {
return 1;
}
plitem_t *setItem = 0;
exprval_t result = { &cexpr_plitem, &setItem };
ectx.result = &result;
[vulkan] Clean up misuse of va for vulkan handles The built up "path" name of the handle resource was not always surviving the intervening call to cexpr_eval_string (in particular, when other handles were created in the process of creating a handle). Rather than simply increase the number of va buffers (where would it end?), just regenerate the path when adding the new handle. It's probably quick enough, and the code is not usually not on a critical path.
2021-04-22 10:47:42 +00:00
ret = !cexpr_eval_string (path, &ectx);
[vulkan] Parse clear values And get the render pass working in general. Note that this is only the render pass and frame buffers: actual commands still have problems.
2021-02-23 05:37:48 +00:00
if (ret) {
VkRenderPass setLayout;
setLayout = QFV_ParseRenderPass (ctx, setItem, pctx->properties);
*handle = (VkRenderPass) setLayout;
[vulkan] Clean up misuse of va for vulkan handles The built up "path" name of the handle resource was not always surviving the intervening call to cexpr_eval_string (in particular, when other handles were created in the process of creating a handle). Rather than simply increase the number of va buffers (where would it end?), just regenerate the path when adding the new handle. It's probably quick enough, and the code is not usually not on a critical path.
2021-04-22 10:47:42 +00:00
// path not guaranteed to survive cexpr_eval_string due to va
path = resource_path (ctx, 0, name);
QFV_AddHandle (ctx->setLayouts, path, (uint64_t) setLayout);
[vulkan] Parse clear values And get the render pass working in general. Note that this is only the render pass and frame buffers: actual commands still have problems.
2021-02-23 05:37:48 +00:00
}
return ret;
}
[vulkan] Clean up some tangled dependencies Dependencies on vkparse.hinc were spreading through the code which I didn't want as that removes a lot of the automation from the automake files. This keeps all parser code internal to vkparse.c's scope, and any accesses required for enum and struct (not yet) definitions can be fetched by name.
2021-01-04 08:26:39 +00:00
static int
[vulkan] Implement pipeline creation The prototypes for handle parsers needed to be changes because it turned out "single" was inappropriate for handles as "single" allocates memory for the parsed object, but handles must be written directly.
2021-01-05 14:42:30 +00:00
parse_VkShaderModule (const plitem_t *item, void **data,
plitem_t *messages, parsectx_t *context)
[vulkan] Clean up some tangled dependencies Dependencies on vkparse.hinc were spreading through the code which I didn't want as that removes a lot of the automation from the automake files. This keeps all parser code internal to vkparse.c's scope, and any accesses required for enum and struct (not yet) definitions can be fetched by name.
2021-01-04 08:26:39 +00:00
{
[vulkan] Implement pipeline creation The prototypes for handle parsers needed to be changes because it turned out "single" was inappropriate for handles as "single" allocates memory for the parsed object, but handles must be written directly.
2021-01-05 14:42:30 +00:00
__auto_type handle = (VkShaderModule *) data[0];
vulkan_ctx_t *ctx = context->vctx;
[vulkan] Rework pipeline parsing for better reuse It's not entirely there yet, but the basics are working. Work is still needed for avoiding duplication of objects (different threads will have different contexts and thus different tables, so necessary per-thread duplication should not become a problem) and general access to arbitrary fields (mostly just parsing the strings)
2021-02-04 08:03:49 +00:00
qfv_device_t *device = ctx->device;
[vulkan] Generate code for resource nodes This makes it easy to add resource nodes defining contextually named resources. It is already used for shaders, set layouts, and pipeline layouts.
2021-01-05 05:15:35 +00:00
[vulkan] Clean up some tangled dependencies Dependencies on vkparse.hinc were spreading through the code which I didn't want as that removes a lot of the automation from the automake files. This keeps all parser code internal to vkparse.c's scope, and any accesses required for enum and struct (not yet) definitions can be fetched by name.
2021-01-04 08:26:39 +00:00
const char *name = PL_String (item);
[vulkan] Take care of the duplicate handles
2021-02-04 11:40:28 +00:00
*handle = (VkShaderModule) QFV_GetHandle (ctx->shaderModules, name);
if (*handle) {
[vulkan] Rework pipeline parsing for better reuse It's not entirely there yet, but the basics are working. Work is still needed for avoiding duplication of objects (different threads will have different contexts and thus different tables, so necessary per-thread duplication should not become a problem) and general access to arbitrary fields (mostly just parsing the strings)
2021-02-04 08:03:49 +00:00
return 1;
}
[vulkan] Add a debug stack to the vulkan instance The stack is arbitrary strings that the validation layer debug callback prints in reverse order after each message. This makes it easy to work out what nodes in a pipeline/render pass plist are causing validation errors. Still have to narrow down the actual line, but the messages seem to help with that. Putting qfvPushDebug/qfvPopDebug around other calls to vulkan should help out a lot, tool. As a bonus, the stack is printed before debug_breakpoint is called, so it's immediately visible in gdb.
2021-11-30 03:24:45 +00:00
qfvPushDebug (ctx, va (ctx->va_ctx, "parse_VkShaderModule: %d", PL_Line (item)));
*handle = QFV_CreateShaderModule (device, name);
qfvPopDebug (ctx);
if (!*handle) {
[vulkan] Rework pipeline parsing for better reuse It's not entirely there yet, but the basics are working. Work is still needed for avoiding duplication of objects (different threads will have different contexts and thus different tables, so necessary per-thread duplication should not become a problem) and general access to arbitrary fields (mostly just parsing the strings)
2021-02-04 08:03:49 +00:00
PL_Message (messages, item, "could not find shader %s", name);
[vulkan] Generate code for resource nodes This makes it easy to add resource nodes defining contextually named resources. It is already used for shaders, set layouts, and pipeline layouts.
2021-01-05 05:15:35 +00:00
return 0;
[vulkan] Clean up some tangled dependencies Dependencies on vkparse.hinc were spreading through the code which I didn't want as that removes a lot of the automation from the automake files. This keeps all parser code internal to vkparse.c's scope, and any accesses required for enum and struct (not yet) definitions can be fetched by name.
2021-01-04 08:26:39 +00:00
}
[vulkan] Take care of the duplicate handles
2021-02-04 11:40:28 +00:00
QFV_AddHandle (ctx->shaderModules, name, (uint64_t) *handle);
[vulkan] Generate code for resource nodes This makes it easy to add resource nodes defining contextually named resources. It is already used for shaders, set layouts, and pipeline layouts.
2021-01-05 05:15:35 +00:00
return 1;
[vulkan] Clean up some tangled dependencies Dependencies on vkparse.hinc were spreading through the code which I didn't want as that removes a lot of the automation from the automake files. This keeps all parser code internal to vkparse.c's scope, and any accesses required for enum and struct (not yet) definitions can be fetched by name.
2021-01-04 08:26:39 +00:00
}
[vulkan] Implement pipeline layout creation It seems to work when parsing the layouts. They can be created in-line (in theory) or in a "setLayouts" node and then referenced by name.
2021-01-04 08:36:11 +00:00
[vulkan] Generate code for resource nodes This makes it easy to add resource nodes defining contextually named resources. It is already used for shaders, set layouts, and pipeline layouts.
2021-01-05 05:15:35 +00:00
static int
[vulkan] Rework pipeline parsing for better reuse It's not entirely there yet, but the basics are working. Work is still needed for avoiding duplication of objects (different threads will have different contexts and thus different tables, so necessary per-thread duplication should not become a problem) and general access to arbitrary fields (mostly just parsing the strings)
2021-02-04 08:03:49 +00:00
parse_VkDescriptorSetLayout (const plfield_t *field, const plitem_t *item,
void *data, plitem_t *messages, void *context)
[vulkan] Generate code for resource nodes This makes it easy to add resource nodes defining contextually named resources. It is already used for shaders, set layouts, and pipeline layouts.
2021-01-05 05:15:35 +00:00
{
[vulkan] Rework pipeline parsing for better reuse It's not entirely there yet, but the basics are working. Work is still needed for avoiding duplication of objects (different threads will have different contexts and thus different tables, so necessary per-thread duplication should not become a problem) and general access to arbitrary fields (mostly just parsing the strings)
2021-02-04 08:03:49 +00:00
__auto_type handle = (VkDescriptorSetLayout *) data;
int ret = 1;
[vulkan] Allow all struct objects to be referenced
2021-02-14 02:20:54 +00:00
parsectx_t *pctx = context;
exprctx_t ectx = *pctx->ectx;
vulkan_ctx_t *ctx = pctx->vctx;
[vulkan] Generate code for resource nodes This makes it easy to add resource nodes defining contextually named resources. It is already used for shaders, set layouts, and pipeline layouts.
2021-01-05 05:15:35 +00:00
[vulkan] Rework pipeline parsing for better reuse It's not entirely there yet, but the basics are working. Work is still needed for avoiding duplication of objects (different threads will have different contexts and thus different tables, so necessary per-thread duplication should not become a problem) and general access to arbitrary fields (mostly just parsing the strings)
2021-02-04 08:03:49 +00:00
const char *name = PL_String (item);
[vulkan] Clean up misuse of va for vulkan handles The built up "path" name of the handle resource was not always surviving the intervening call to cexpr_eval_string (in particular, when other handles were created in the process of creating a handle). Rather than simply increase the number of va buffers (where would it end?), just regenerate the path when adding the new handle. It's probably quick enough, and the code is not usually not on a critical path.
2021-04-22 10:47:42 +00:00
const char *path = resource_path (ctx, "setLayouts", name);
[util] Make developer flag names easier to manage They're now an enum, and the flag part of the name is all lowercase, but now the flag definitions and names list will never get out of sync.
2021-03-29 10:58:00 +00:00
Sys_MaskPrintf (SYS_vulkan_parse, "parse_VkDescriptorSetLayout: %s\n",
[vulkan] Clean up misuse of va for vulkan handles The built up "path" name of the handle resource was not always surviving the intervening call to cexpr_eval_string (in particular, when other handles were created in the process of creating a handle). Rather than simply increase the number of va buffers (where would it end?), just regenerate the path when adding the new handle. It's probably quick enough, and the code is not usually not on a critical path.
2021-04-22 10:47:42 +00:00
path);
[vulkan] Rework pipeline parsing for better reuse It's not entirely there yet, but the basics are working. Work is still needed for avoiding duplication of objects (different threads will have different contexts and thus different tables, so necessary per-thread duplication should not become a problem) and general access to arbitrary fields (mostly just parsing the strings)
2021-02-04 08:03:49 +00:00
[vulkan] Clean up misuse of va for vulkan handles The built up "path" name of the handle resource was not always surviving the intervening call to cexpr_eval_string (in particular, when other handles were created in the process of creating a handle). Rather than simply increase the number of va buffers (where would it end?), just regenerate the path when adding the new handle. It's probably quick enough, and the code is not usually not on a critical path.
2021-04-22 10:47:42 +00:00
*handle = (VkDescriptorSetLayout) QFV_GetHandle (ctx->setLayouts, path);
[vulkan] Take care of the duplicate handles
2021-02-04 11:40:28 +00:00
if (*handle) {
[vulkan] Rework pipeline parsing for better reuse It's not entirely there yet, but the basics are working. Work is still needed for avoiding duplication of objects (different threads will have different contexts and thus different tables, so necessary per-thread duplication should not become a problem) and general access to arbitrary fields (mostly just parsing the strings)
2021-02-04 08:03:49 +00:00
return 1;
[vulkan] Generate code for resource nodes This makes it easy to add resource nodes defining contextually named resources. It is already used for shaders, set layouts, and pipeline layouts.
2021-01-05 05:15:35 +00:00
}
[vulkan] Rework pipeline parsing for better reuse It's not entirely there yet, but the basics are working. Work is still needed for avoiding duplication of objects (different threads will have different contexts and thus different tables, so necessary per-thread duplication should not become a problem) and general access to arbitrary fields (mostly just parsing the strings)
2021-02-04 08:03:49 +00:00
plitem_t *setItem = 0;
exprval_t result = { &cexpr_plitem, &setItem };
ectx.result = &result;
[vulkan] Clean up misuse of va for vulkan handles The built up "path" name of the handle resource was not always surviving the intervening call to cexpr_eval_string (in particular, when other handles were created in the process of creating a handle). Rather than simply increase the number of va buffers (where would it end?), just regenerate the path when adding the new handle. It's probably quick enough, and the code is not usually not on a critical path.
2021-04-22 10:47:42 +00:00
ret = !cexpr_eval_string (path, &ectx);
[vulkan] Rework pipeline parsing for better reuse It's not entirely there yet, but the basics are working. Work is still needed for avoiding duplication of objects (different threads will have different contexts and thus different tables, so necessary per-thread duplication should not become a problem) and general access to arbitrary fields (mostly just parsing the strings)
2021-02-04 08:03:49 +00:00
if (ret) {
VkDescriptorSetLayout setLayout;
[vulkan] Start moving towards a deferred renderer After getting lights even vaguely working for alias models, I realized that it just wasn't going to be feasible to do nice lighting with forward rendering. This gets the bulk of the work done for deferred rendering, but still need to sort out the shaders before any real testing can be done.
2021-02-14 02:35:06 +00:00
setLayout = QFV_ParseDescriptorSetLayout (ctx, setItem,
pctx->properties);
[vulkan] Rework pipeline parsing for better reuse It's not entirely there yet, but the basics are working. Work is still needed for avoiding duplication of objects (different threads will have different contexts and thus different tables, so necessary per-thread duplication should not become a problem) and general access to arbitrary fields (mostly just parsing the strings)
2021-02-04 08:03:49 +00:00
*handle = (VkDescriptorSetLayout) setLayout;
[vulkan] Clean up misuse of va for vulkan handles The built up "path" name of the handle resource was not always surviving the intervening call to cexpr_eval_string (in particular, when other handles were created in the process of creating a handle). Rather than simply increase the number of va buffers (where would it end?), just regenerate the path when adding the new handle. It's probably quick enough, and the code is not usually not on a critical path.
2021-04-22 10:47:42 +00:00
// path not guaranteed to survive cexpr_eval_string due to va
path = resource_path (ctx, "setLayouts", name);
QFV_AddHandle (ctx->setLayouts, path, (uint64_t) setLayout);
[vulkan] Rework pipeline parsing for better reuse It's not entirely there yet, but the basics are working. Work is still needed for avoiding duplication of objects (different threads will have different contexts and thus different tables, so necessary per-thread duplication should not become a problem) and general access to arbitrary fields (mostly just parsing the strings)
2021-02-04 08:03:49 +00:00
}
return ret;
[vulkan] Generate code for resource nodes This makes it easy to add resource nodes defining contextually named resources. It is already used for shaders, set layouts, and pipeline layouts.
2021-01-05 05:15:35 +00:00
}
[vulkan] Implement pipeline layout creation It seems to work when parsing the layouts. They can be created in-line (in theory) or in a "setLayouts" node and then referenced by name.
2021-01-04 08:36:11 +00:00
[vulkan] Implement pipeline creation The prototypes for handle parsers needed to be changes because it turned out "single" was inappropriate for handles as "single" allocates memory for the parsed object, but handles must be written directly.
2021-01-05 14:42:30 +00:00
static int
[vulkan] Rework pipeline parsing for better reuse It's not entirely there yet, but the basics are working. Work is still needed for avoiding duplication of objects (different threads will have different contexts and thus different tables, so necessary per-thread duplication should not become a problem) and general access to arbitrary fields (mostly just parsing the strings)
2021-02-04 08:03:49 +00:00
parse_VkPipelineLayout (const plitem_t *item, void **data,
plitem_t *messages, parsectx_t *context)
[vulkan] Implement pipeline creation The prototypes for handle parsers needed to be changes because it turned out "single" was inappropriate for handles as "single" allocates memory for the parsed object, but handles must be written directly.
2021-01-05 14:42:30 +00:00
{
[vulkan] Rework pipeline parsing for better reuse It's not entirely there yet, but the basics are working. Work is still needed for avoiding duplication of objects (different threads will have different contexts and thus different tables, so necessary per-thread duplication should not become a problem) and general access to arbitrary fields (mostly just parsing the strings)
2021-02-04 08:03:49 +00:00
__auto_type handle = (VkPipelineLayout *) data[0];
int ret = 1;
[vulkan] Allow all struct objects to be referenced
2021-02-14 02:20:54 +00:00
exprctx_t ectx = *context->ectx;
vulkan_ctx_t *ctx = context->vctx;
[vulkan] Rework pipeline parsing for better reuse It's not entirely there yet, but the basics are working. Work is still needed for avoiding duplication of objects (different threads will have different contexts and thus different tables, so necessary per-thread duplication should not become a problem) and general access to arbitrary fields (mostly just parsing the strings)
2021-02-04 08:03:49 +00:00
const char *name = PL_String (item);
[vulkan] Clean up misuse of va for vulkan handles The built up "path" name of the handle resource was not always surviving the intervening call to cexpr_eval_string (in particular, when other handles were created in the process of creating a handle). Rather than simply increase the number of va buffers (where would it end?), just regenerate the path when adding the new handle. It's probably quick enough, and the code is not usually not on a critical path.
2021-04-22 10:47:42 +00:00
const char *path = resource_path (ctx, "pipelineLayouts", name);
Sys_MaskPrintf (SYS_vulkan_parse, "parse_VkPipelineLayout: %s\n", path);
[vulkan] Rework pipeline parsing for better reuse It's not entirely there yet, but the basics are working. Work is still needed for avoiding duplication of objects (different threads will have different contexts and thus different tables, so necessary per-thread duplication should not become a problem) and general access to arbitrary fields (mostly just parsing the strings)
2021-02-04 08:03:49 +00:00
[vulkan] Clean up misuse of va for vulkan handles The built up "path" name of the handle resource was not always surviving the intervening call to cexpr_eval_string (in particular, when other handles were created in the process of creating a handle). Rather than simply increase the number of va buffers (where would it end?), just regenerate the path when adding the new handle. It's probably quick enough, and the code is not usually not on a critical path.
2021-04-22 10:47:42 +00:00
*handle = (VkPipelineLayout) QFV_GetHandle (ctx->pipelineLayouts, path);
[vulkan] Take care of the duplicate handles
2021-02-04 11:40:28 +00:00
if (*handle) {
[vulkan] Rework pipeline parsing for better reuse It's not entirely there yet, but the basics are working. Work is still needed for avoiding duplication of objects (different threads will have different contexts and thus different tables, so necessary per-thread duplication should not become a problem) and general access to arbitrary fields (mostly just parsing the strings)
2021-02-04 08:03:49 +00:00
return 1;
}
plitem_t *setItem = 0;
exprval_t result = { &cexpr_plitem, &setItem };
ectx.result = &result;
[vulkan] Clean up misuse of va for vulkan handles The built up "path" name of the handle resource was not always surviving the intervening call to cexpr_eval_string (in particular, when other handles were created in the process of creating a handle). Rather than simply increase the number of va buffers (where would it end?), just regenerate the path when adding the new handle. It's probably quick enough, and the code is not usually not on a critical path.
2021-04-22 10:47:42 +00:00
ret = !cexpr_eval_string (path, &ectx);
[vulkan] Rework pipeline parsing for better reuse It's not entirely there yet, but the basics are working. Work is still needed for avoiding duplication of objects (different threads will have different contexts and thus different tables, so necessary per-thread duplication should not become a problem) and general access to arbitrary fields (mostly just parsing the strings)
2021-02-04 08:03:49 +00:00
if (ret) {
VkPipelineLayout layout;
[vulkan] Start moving towards a deferred renderer After getting lights even vaguely working for alias models, I realized that it just wasn't going to be feasible to do nice lighting with forward rendering. This gets the bulk of the work done for deferred rendering, but still need to sort out the shaders before any real testing can be done.
2021-02-14 02:35:06 +00:00
layout = QFV_ParsePipelineLayout (ctx, setItem, context->properties);
[vulkan] Rework pipeline parsing for better reuse It's not entirely there yet, but the basics are working. Work is still needed for avoiding duplication of objects (different threads will have different contexts and thus different tables, so necessary per-thread duplication should not become a problem) and general access to arbitrary fields (mostly just parsing the strings)
2021-02-04 08:03:49 +00:00
*handle = (VkPipelineLayout) layout;
[vulkan] Clean up misuse of va for vulkan handles The built up "path" name of the handle resource was not always surviving the intervening call to cexpr_eval_string (in particular, when other handles were created in the process of creating a handle). Rather than simply increase the number of va buffers (where would it end?), just regenerate the path when adding the new handle. It's probably quick enough, and the code is not usually not on a critical path.
2021-04-22 10:47:42 +00:00
// path not guaranteed to survive cexpr_eval_string due to va
path = resource_path (ctx, "pipelineLayouts", name);
QFV_AddHandle (ctx->pipelineLayouts, path, (uint64_t) layout);
[vulkan] Rework pipeline parsing for better reuse It's not entirely there yet, but the basics are working. Work is still needed for avoiding duplication of objects (different threads will have different contexts and thus different tables, so necessary per-thread duplication should not become a problem) and general access to arbitrary fields (mostly just parsing the strings)
2021-02-04 08:03:49 +00:00
}
return ret;
[vulkan] Implement pipeline creation The prototypes for handle parsers needed to be changes because it turned out "single" was inappropriate for handles as "single" allocates memory for the parsed object, but handles must be written directly.
2021-01-05 14:42:30 +00:00
}
[vulkan] Start moving towards a deferred renderer After getting lights even vaguely working for alias models, I realized that it just wasn't going to be feasible to do nice lighting with forward rendering. This gets the bulk of the work done for deferred rendering, but still need to sort out the shaders before any real testing can be done.
2021-02-14 02:35:06 +00:00
static int
parse_VkImage (const plitem_t *item, void **data, plitem_t *messages,
parsectx_t *context)
{
__auto_type handle = (VkImage *) data[0];
int ret = 1;
exprctx_t ectx = *context->ectx;
vulkan_ctx_t *ctx = context->vctx;
const char *name = PL_String (item);
[vulkan] Clean up misuse of va for vulkan handles The built up "path" name of the handle resource was not always surviving the intervening call to cexpr_eval_string (in particular, when other handles were created in the process of creating a handle). Rather than simply increase the number of va buffers (where would it end?), just regenerate the path when adding the new handle. It's probably quick enough, and the code is not usually not on a critical path.
2021-04-22 10:47:42 +00:00
const char *path = resource_path (ctx, "images", name);
Sys_MaskPrintf (SYS_vulkan_parse, "parse_VkImage: %s\n", path);
[vulkan] Start moving towards a deferred renderer After getting lights even vaguely working for alias models, I realized that it just wasn't going to be feasible to do nice lighting with forward rendering. This gets the bulk of the work done for deferred rendering, but still need to sort out the shaders before any real testing can be done.
2021-02-14 02:35:06 +00:00
[vulkan] Clean up misuse of va for vulkan handles The built up "path" name of the handle resource was not always surviving the intervening call to cexpr_eval_string (in particular, when other handles were created in the process of creating a handle). Rather than simply increase the number of va buffers (where would it end?), just regenerate the path when adding the new handle. It's probably quick enough, and the code is not usually not on a critical path.
2021-04-22 10:47:42 +00:00
*handle = (VkImage) QFV_GetHandle (ctx->images, path);
[vulkan] Start moving towards a deferred renderer After getting lights even vaguely working for alias models, I realized that it just wasn't going to be feasible to do nice lighting with forward rendering. This gets the bulk of the work done for deferred rendering, but still need to sort out the shaders before any real testing can be done.
2021-02-14 02:35:06 +00:00
if (*handle) {
return 1;
}
plitem_t *imageItem = 0;
exprval_t result = { &cexpr_plitem, &imageItem };
ectx.result = &result;
[vulkan] Clean up misuse of va for vulkan handles The built up "path" name of the handle resource was not always surviving the intervening call to cexpr_eval_string (in particular, when other handles were created in the process of creating a handle). Rather than simply increase the number of va buffers (where would it end?), just regenerate the path when adding the new handle. It's probably quick enough, and the code is not usually not on a critical path.
2021-04-22 10:47:42 +00:00
ret = !cexpr_eval_string (path, &ectx);
[vulkan] Start moving towards a deferred renderer After getting lights even vaguely working for alias models, I realized that it just wasn't going to be feasible to do nice lighting with forward rendering. This gets the bulk of the work done for deferred rendering, but still need to sort out the shaders before any real testing can be done.
2021-02-14 02:35:06 +00:00
if (ret) {
VkImage image;
image = QFV_ParseImage (ctx, imageItem, context->properties);
*handle = (VkImage) image;
[vulkan] Clean up misuse of va for vulkan handles The built up "path" name of the handle resource was not always surviving the intervening call to cexpr_eval_string (in particular, when other handles were created in the process of creating a handle). Rather than simply increase the number of va buffers (where would it end?), just regenerate the path when adding the new handle. It's probably quick enough, and the code is not usually not on a critical path.
2021-04-22 10:47:42 +00:00
// path not guaranteed to survive cexpr_eval_string due to va
path = resource_path (ctx, "images", name);
QFV_AddHandle (ctx->images, path, (uint64_t) image);
[vulkan] Start moving towards a deferred renderer After getting lights even vaguely working for alias models, I realized that it just wasn't going to be feasible to do nice lighting with forward rendering. This gets the bulk of the work done for deferred rendering, but still need to sort out the shaders before any real testing can be done.
2021-02-14 02:35:06 +00:00
}
return ret;
}
[vulkan] Break render pass parsing away from swapchain This allows a single render pass description to be used for both on-screen and off-screen targets. While Vulkan does allow a VkRenderPass to be used with any compatible frame buffer, and vkparse caches a VkRenderPass created from the same description, this allows the same description to be used for a compatible off-screen target without any dependence on the swapchain. However, there is a problem in the caching when it comes to targeting outputs with different formats.
2022-04-02 02:42:36 +00:00
exprtype_t VkImageView_type = {
[cexpr] Require designated initializers for exprtype_t This will make expanding it much safer in the future.
2022-04-24 05:55:35 +00:00
.name = "VkImageView",
.size = sizeof (VkImageView),
.binops = 0,
.unops = 0,
.data = 0
[vulkan] Start moving towards a deferred renderer After getting lights even vaguely working for alias models, I realized that it just wasn't going to be feasible to do nice lighting with forward rendering. This gets the bulk of the work done for deferred rendering, but still need to sort out the shaders before any real testing can be done.
2021-02-14 02:35:06 +00:00
};
static int
parse_VkImageView (const plfield_t *field, const plitem_t *item, void *data,
plitem_t *messages, void *_context)
{
parsectx_t *context = _context;
__auto_type handle = (VkImageView *) data;
int ret = 1;
exprctx_t ectx = *context->ectx;
vulkan_ctx_t *ctx = context->vctx;
const char *name = PL_String (item);
[vulkan] Clean up misuse of va for vulkan handles The built up "path" name of the handle resource was not always surviving the intervening call to cexpr_eval_string (in particular, when other handles were created in the process of creating a handle). Rather than simply increase the number of va buffers (where would it end?), just regenerate the path when adding the new handle. It's probably quick enough, and the code is not usually not on a critical path.
2021-04-22 10:47:42 +00:00
const char *path = resource_path (ctx, "imageViews", name);
Sys_MaskPrintf (SYS_vulkan_parse, "parse_VkImageView: %s\n", path);
[vulkan] Start moving towards a deferred renderer After getting lights even vaguely working for alias models, I realized that it just wasn't going to be feasible to do nice lighting with forward rendering. This gets the bulk of the work done for deferred rendering, but still need to sort out the shaders before any real testing can be done.
2021-02-14 02:35:06 +00:00
[vulkan] Clean up misuse of va for vulkan handles The built up "path" name of the handle resource was not always surviving the intervening call to cexpr_eval_string (in particular, when other handles were created in the process of creating a handle). Rather than simply increase the number of va buffers (where would it end?), just regenerate the path when adding the new handle. It's probably quick enough, and the code is not usually not on a critical path.
2021-04-22 10:47:42 +00:00
*handle = (VkImageView) QFV_GetHandle (ctx->imageViews, path);
[vulkan] Start moving towards a deferred renderer After getting lights even vaguely working for alias models, I realized that it just wasn't going to be feasible to do nice lighting with forward rendering. This gets the bulk of the work done for deferred rendering, but still need to sort out the shaders before any real testing can be done.
2021-02-14 02:35:06 +00:00
if (*handle) {
return 1;
}
exprval_t *value = 0;
exprval_t result = { &cexpr_exprval, &value };
ectx.result = &result;
[vulkan] Clean up misuse of va for vulkan handles The built up "path" name of the handle resource was not always surviving the intervening call to cexpr_eval_string (in particular, when other handles were created in the process of creating a handle). Rather than simply increase the number of va buffers (where would it end?), just regenerate the path when adding the new handle. It's probably quick enough, and the code is not usually not on a critical path.
2021-04-22 10:47:42 +00:00
ret = !cexpr_eval_string (path, &ectx);
[vulkan] Start moving towards a deferred renderer After getting lights even vaguely working for alias models, I realized that it just wasn't going to be feasible to do nice lighting with forward rendering. This gets the bulk of the work done for deferred rendering, but still need to sort out the shaders before any real testing can be done.
2021-02-14 02:35:06 +00:00
plitem_t *imageViewItem = 0;
if (ret) {
VkImageView imageView;
[vulkan] Break render pass parsing away from swapchain This allows a single render pass description to be used for both on-screen and off-screen targets. While Vulkan does allow a VkRenderPass to be used with any compatible frame buffer, and vkparse caches a VkRenderPass created from the same description, this allows the same description to be used for a compatible off-screen target without any dependence on the swapchain. However, there is a problem in the caching when it comes to targeting outputs with different formats.
2022-04-02 02:42:36 +00:00
if (value->type == &VkImageView_type) {
[vulkan] Start moving towards a deferred renderer After getting lights even vaguely working for alias models, I realized that it just wasn't going to be feasible to do nice lighting with forward rendering. This gets the bulk of the work done for deferred rendering, but still need to sort out the shaders before any real testing can be done.
2021-02-14 02:35:06 +00:00
imageView = *(VkImageView *) value->value;
} else if (value->type == &cexpr_plitem) {
imageView = QFV_ParseImageView (ctx, imageViewItem,
context->properties);
[vulkan] Clean up misuse of va for vulkan handles The built up "path" name of the handle resource was not always surviving the intervening call to cexpr_eval_string (in particular, when other handles were created in the process of creating a handle). Rather than simply increase the number of va buffers (where would it end?), just regenerate the path when adding the new handle. It's probably quick enough, and the code is not usually not on a critical path.
2021-04-22 10:47:42 +00:00
// path not guaranteed to survive cexpr_eval_string due to va
path = resource_path (ctx, "imageViews", name);
QFV_AddHandle (ctx->imageViews, path, (uint64_t) imageView);
[vulkan] Start moving towards a deferred renderer After getting lights even vaguely working for alias models, I realized that it just wasn't going to be feasible to do nice lighting with forward rendering. This gets the bulk of the work done for deferred rendering, but still need to sort out the shaders before any real testing can be done.
2021-02-14 02:35:06 +00:00
} else {
PL_Message (messages, item, "not a VkImageView");
return 0;
}
*handle = (VkImageView) imageView;
}
return ret;
}
[vulkan] Implement pipeline layout creation It seems to work when parsing the layouts. They can be created in-line (in theory) or in a "setLayouts" node and then referenced by name.
2021-01-04 08:36:11 +00:00
static const char *
[vulkan] Generate code for vulkan handles The handles can be created in place or in resource blocks and referred to by name (resource block code gen next).
2021-01-04 23:38:35 +00:00
handleref_getkey (const void *hr, void *unused)
[vulkan] Implement pipeline layout creation It seems to work when parsing the layouts. They can be created in-line (in theory) or in a "setLayouts" node and then referenced by name.
2021-01-04 08:36:11 +00:00
{
[vulkan] Generate code for vulkan handles The handles can be created in place or in resource blocks and referred to by name (resource block code gen next).
2021-01-04 23:38:35 +00:00
return ((handleref_t *)hr)->name;
[vulkan] Implement pipeline layout creation It seems to work when parsing the layouts. They can be created in-line (in theory) or in a "setLayouts" node and then referenced by name.
2021-01-04 08:36:11 +00:00
}
static void
[vulkan] Generate code for vulkan handles The handles can be created in place or in resource blocks and referred to by name (resource block code gen next).
2021-01-04 23:38:35 +00:00
handleref_free (void *hr, void *_ctx)
[vulkan] Implement pipeline layout creation It seems to work when parsing the layouts. They can be created in-line (in theory) or in a "setLayouts" node and then referenced by name.
2021-01-04 08:36:11 +00:00
{
[vulkan] Generate code for vulkan handles The handles can be created in place or in resource blocks and referred to by name (resource block code gen next).
2021-01-04 23:38:35 +00:00
__auto_type handleref = (handleref_t *) hr;
free (handleref->name);
free (handleref);
[vulkan] Implement pipeline layout creation It seems to work when parsing the layouts. They can be created in-line (in theory) or in a "setLayouts" node and then referenced by name.
2021-01-04 08:36:11 +00:00
}
[vulkan] Generate code for vulkan handles The handles can be created in place or in resource blocks and referred to by name (resource block code gen next).
2021-01-04 23:38:35 +00:00
static void
setLayout_free (void *hr, void *_ctx)
[vulkan] Implement pipeline layout creation It seems to work when parsing the layouts. They can be created in-line (in theory) or in a "setLayouts" node and then referenced by name.
2021-01-04 08:36:11 +00:00
{
[vulkan] Generate code for vulkan handles The handles can be created in place or in resource blocks and referred to by name (resource block code gen next).
2021-01-04 23:38:35 +00:00
__auto_type handleref = (handleref_t *) hr;
__auto_type layout = (VkDescriptorSetLayout) handleref->handle;
__auto_type ctx = (vulkan_ctx_t *) _ctx;
[vulkan] Implement pipeline layout creation It seems to work when parsing the layouts. They can be created in-line (in theory) or in a "setLayouts" node and then referenced by name.
2021-01-04 08:36:11 +00:00
qfv_device_t *device = ctx->device;
qfv_devfuncs_t *dfunc = device->funcs;
[vulkan] Clear out the resource tables on shutdown This would take care of undestroyed resources if there wasn't a problem with invalid memory use. Not sure what's going on just yet.
2021-01-05 08:48:00 +00:00
if (layout) {
dfunc->vkDestroyDescriptorSetLayout (device->dev, layout, 0);
}
[vulkan] Generate code for vulkan handles The handles can be created in place or in resource blocks and referred to by name (resource block code gen next).
2021-01-04 23:38:35 +00:00
handleref_free (handleref, ctx);
}
[vulkan] Implement pipeline layout creation It seems to work when parsing the layouts. They can be created in-line (in theory) or in a "setLayouts" node and then referenced by name.
2021-01-04 08:36:11 +00:00
[vulkan] Generate code for resource nodes This makes it easy to add resource nodes defining contextually named resources. It is already used for shaders, set layouts, and pipeline layouts.
2021-01-05 05:15:35 +00:00
static void
shaderModule_free (void *hr, void *_ctx)
{
__auto_type handleref = (handleref_t *) hr;
__auto_type module = (VkShaderModule) handleref->handle;
__auto_type ctx = (vulkan_ctx_t *) _ctx;
qfv_device_t *device = ctx->device;
qfv_devfuncs_t *dfunc = device->funcs;
[vulkan] Clear out the resource tables on shutdown This would take care of undestroyed resources if there wasn't a problem with invalid memory use. Not sure what's going on just yet.
2021-01-05 08:48:00 +00:00
if (module) {
dfunc->vkDestroyShaderModule (device->dev, module, 0);
}
[vulkan] Generate code for resource nodes This makes it easy to add resource nodes defining contextually named resources. It is already used for shaders, set layouts, and pipeline layouts.
2021-01-05 05:15:35 +00:00
handleref_free (handleref, ctx);
}
static void
pipelineLayout_free (void *hr, void *_ctx)
{
__auto_type handleref = (handleref_t *) hr;
__auto_type layout = (VkPipelineLayout) handleref->handle;
__auto_type ctx = (vulkan_ctx_t *) _ctx;
qfv_device_t *device = ctx->device;
qfv_devfuncs_t *dfunc = device->funcs;
[vulkan] Clear out the resource tables on shutdown This would take care of undestroyed resources if there wasn't a problem with invalid memory use. Not sure what's going on just yet.
2021-01-05 08:48:00 +00:00
if (layout) {
dfunc->vkDestroyPipelineLayout (device->dev, layout, 0);
};
[vulkan] Generate code for resource nodes This makes it easy to add resource nodes defining contextually named resources. It is already used for shaders, set layouts, and pipeline layouts.
2021-01-05 05:15:35 +00:00
handleref_free (handleref, ctx);
}
[vulkan] Parse descriptor pools
2021-01-09 16:53:15 +00:00
static void
descriptorPool_free (void *hr, void *_ctx)
{
__auto_type handleref = (handleref_t *) hr;
__auto_type pool = (VkDescriptorPool) handleref->handle;
__auto_type ctx = (vulkan_ctx_t *) _ctx;
qfv_device_t *device = ctx->device;
qfv_devfuncs_t *dfunc = device->funcs;
if (pool) {
dfunc->vkDestroyDescriptorPool (device->dev, pool, 0);
};
handleref_free (handleref, ctx);
}
[vulkan] Parse sampler definitions
2021-01-10 06:50:24 +00:00
static void
sampler_free (void *hr, void *_ctx)
{
__auto_type handleref = (handleref_t *) hr;
__auto_type sampler = (VkSampler) handleref->handle;
__auto_type ctx = (vulkan_ctx_t *) _ctx;
qfv_device_t *device = ctx->device;
qfv_devfuncs_t *dfunc = device->funcs;
if (sampler) {
dfunc->vkDestroySampler (device->dev, sampler, 0);
};
handleref_free (handleref, ctx);
}
[vulkan] Start moving towards a deferred renderer After getting lights even vaguely working for alias models, I realized that it just wasn't going to be feasible to do nice lighting with forward rendering. This gets the bulk of the work done for deferred rendering, but still need to sort out the shaders before any real testing can be done.
2021-02-14 02:35:06 +00:00
static void
image_free (void *hr, void *_ctx)
{
__auto_type handleref = (handleref_t *) hr;
__auto_type image = (VkImage) handleref->handle;
__auto_type ctx = (vulkan_ctx_t *) _ctx;
qfv_device_t *device = ctx->device;
qfv_devfuncs_t *dfunc = device->funcs;
if (image) {
dfunc->vkDestroyImage (device->dev, image, 0);
};
handleref_free (handleref, ctx);
}
static void
imageView_free (void *hr, void *_ctx)
{
__auto_type handleref = (handleref_t *) hr;
__auto_type imageView = (VkImageView) handleref->handle;
__auto_type ctx = (vulkan_ctx_t *) _ctx;
qfv_device_t *device = ctx->device;
qfv_devfuncs_t *dfunc = device->funcs;
if (imageView) {
dfunc->vkDestroyImageView (device->dev, imageView, 0);
};
handleref_free (handleref, ctx);
}
[vulkan] Parse clear values And get the render pass working in general. Note that this is only the render pass and frame buffers: actual commands still have problems.
2021-02-23 05:37:48 +00:00
static void
renderpass_free (void *hr, void *_ctx)
{
__auto_type handleref = (handleref_t *) hr;
__auto_type renderpass = (VkRenderPass) handleref->handle;
__auto_type ctx = (vulkan_ctx_t *) _ctx;
qfv_device_t *device = ctx->device;
qfv_devfuncs_t *dfunc = device->funcs;
if (renderpass) {
dfunc->vkDestroyRenderPass (device->dev, renderpass, 0);
};
handleref_free (handleref, ctx);
}
[vulkan] Generate code for vulkan handles The handles can be created in place or in resource blocks and referred to by name (resource block code gen next).
2021-01-04 23:38:35 +00:00
static hashtab_t *enum_symtab;
[vulkan] Implement pipeline layout creation It seems to work when parsing the layouts. They can be created in-line (in theory) or in a "setLayouts" node and then referenced by name.
2021-01-04 08:36:11 +00:00
[vulkan] Generate code for vulkan handles The handles can be created in place or in resource blocks and referred to by name (resource block code gen next).
2021-01-04 23:38:35 +00:00
static int
parse_BasePipeline (const plitem_t *item, void **data,
plitem_t *messages, parsectx_t *context)
{
*(VkPipeline *) data = 0;
PL_Message (messages, item, "not implemented");
return 0;
[vulkan] Implement pipeline layout creation It seems to work when parsing the layouts. They can be created in-line (in theory) or in a "setLayouts" node and then referenced by name.
2021-01-04 08:36:11 +00:00
}
[vulkan] Ease writing of specialization data While using binary data objects for specialization data works for bools (as they can be 0 or -1), they don't work so well for numeric values due to having to get the byte order correct and thus are not portable, and difficult to get right. Binary data is still supported, but the data can be written as a string with an array(...) "constructor" expression taking any number of parameters, with each parameter itself being an expression (though values are limited at this stage). Due to the plist format, quotes are required around the expression ("array(...)")
2021-12-01 05:49:23 +00:00
typedef struct data_array_s DARRAY_TYPE(byte) data_array_t;
static void
data_array (const exprval_t **params, exprval_t *result, exprctx_t *context)
{
size_t offset = 0;
[vulkan] Copy array() parameters correctly I had forgotten that the parameters are in reverse order, and even if I had remembered, I forgot to reset offset before the second loop. Pre-decrementing offset takes care of both issues at once.
2021-12-06 10:29:37 +00:00
// params are in reverse order, but this works for calculating the size
// of the buffer
[vulkan] Ease writing of specialization data While using binary data objects for specialization data works for bools (as they can be 0 or -1), they don't work so well for numeric values due to having to get the byte order correct and thus are not portable, and difficult to get right. Binary data is still supported, but the data can be written as a string with an array(...) "constructor" expression taking any number of parameters, with each parameter itself being an expression (though values are limited at this stage). Due to the plist format, quotes are required around the expression ("array(...)")
2021-12-01 05:49:23 +00:00
for (const exprval_t **param = params; *param; param++) {
offset += (*param)->type->size;
}
__auto_type data = DARRAY_ALLOCFIXED_OBJ (data_array_t, offset,
cmemalloc, context->memsuper);
for (const exprval_t **param = params; *param; param++) {
size_t size = (*param)->type->size;
[vulkan] Copy array() parameters correctly I had forgotten that the parameters are in reverse order, and even if I had remembered, I forgot to reset offset before the second loop. Pre-decrementing offset takes care of both issues at once.
2021-12-06 10:29:37 +00:00
// pre-decrement offset because params are in reverse order
offset -= size;
[vulkan] Ease writing of specialization data While using binary data objects for specialization data works for bools (as they can be 0 or -1), they don't work so well for numeric values due to having to get the byte order correct and thus are not portable, and difficult to get right. Binary data is still supported, but the data can be written as a string with an array(...) "constructor" expression taking any number of parameters, with each parameter itself being an expression (though values are limited at this stage). Due to the plist format, quotes are required around the expression ("array(...)")
2021-12-01 05:49:23 +00:00
memcpy (data->a + offset, (*param)->value, size);
}
*(data_array_t **) result->value = data;
}
static exprtype_t data_array_type = {
[cexpr] Require designated initializers for exprtype_t This will make expanding it much safer in the future.
2022-04-24 05:55:35 +00:00
.name = "array",
.size = sizeof (data_array_t *),
.binops = 0,
.unops = 0,
[vulkan] Ease writing of specialization data While using binary data objects for specialization data works for bools (as they can be 0 or -1), they don't work so well for numeric values due to having to get the byte order correct and thus are not portable, and difficult to get right. Binary data is still supported, but the data can be written as a string with an array(...) "constructor" expression taking any number of parameters, with each parameter itself being an expression (though values are limited at this stage). Due to the plist format, quotes are required around the expression ("array(...)")
2021-12-01 05:49:23 +00:00
};
static exprfunc_t data_array_func[] = {
{ &data_array_type, -1, 0, data_array },
{}
};
static exprsym_t data_array_symbols[] = {
{ "array", &cexpr_function, data_array_func },
{}
};
static exprtab_t data_array_symtab = {
data_array_symbols,
};
static int
parse_specialization_data (const plitem_t *item, void **data,
plitem_t *messages, parsectx_t *context)
{
size_t *size_ptr = (size_t *) data[0];
void **data_ptr = (void **) data[1];
if (PL_Type (item) == QFBinary) {
const void *bindata = PL_BinaryData (item);
size_t binsize = PL_BinarySize (item);
*data_ptr = vkparse_alloc (context, binsize);
memcpy (*data_ptr, bindata, binsize);
*size_ptr = binsize;
return 1;
}
data_array_t *da= 0;
exprctx_t ectx = *((parsectx_t *)context)->ectx;
exprval_t result = { &data_array_type, &da };
[vulkan] Connect up the cexpr library This will make property list expressions easier to work with. The library is rather limited right now (trig, dot, min/max/bound) but even just min adds a lot of functionality.
2021-12-04 05:09:57 +00:00
ectx.parent = ((parsectx_t *)context)->ectx;
[vulkan] Ease writing of specialization data While using binary data objects for specialization data works for bools (as they can be 0 or -1), they don't work so well for numeric values due to having to get the byte order correct and thus are not portable, and difficult to get right. Binary data is still supported, but the data can be written as a string with an array(...) "constructor" expression taking any number of parameters, with each parameter itself being an expression (though values are limited at this stage). Due to the plist format, quotes are required around the expression ("array(...)")
2021-12-01 05:49:23 +00:00
ectx.symtab = &data_array_symtab;
ectx.result = &result;
const char *valstr = PL_String (item);
//Sys_MaskPrintf (SYS_vulkan_parse,
// "parse_specialization_data: %s %zd %d %p %p %s\n",
// field->name, field->offset, field->type, field->parser,
// field->data, valstr);
int ret = !cexpr_eval_string (valstr, &ectx);
if (!ret) {
PL_Message (messages, item, "error parsing specialization data: %s",
valstr);
} else {
*size_ptr = da->size;
*data_ptr = da->a;
[vulkan] Copy array() parameters correctly I had forgotten that the parameters are in reverse order, and even if I had remembered, I forgot to reset offset before the second loop. Pre-decrementing offset takes care of both issues at once.
2021-12-06 10:29:37 +00:00
//for (size_t i = 0; i < da->size; i++) {
// Sys_Printf (" %02x", da->a[i]);
//}
//Sys_Printf ("\n");
[vulkan] Ease writing of specialization data While using binary data objects for specialization data works for bools (as they can be 0 or -1), they don't work so well for numeric values due to having to get the byte order correct and thus are not portable, and difficult to get right. Binary data is still supported, but the data can be written as a string with an array(...) "constructor" expression taking any number of parameters, with each parameter itself being an expression (though values are limited at this stage). Due to the plist format, quotes are required around the expression ("array(...)")
2021-12-01 05:49:23 +00:00
}
return ret;
}
[vulkan] Generate code for vulkan handles The handles can be created in place or in resource blocks and referred to by name (resource block code gen next).
2021-01-04 23:38:35 +00:00
#include "libs/video/renderer/vulkan/vkparse.cinc"
[vulkan] Break render pass parsing away from swapchain This allows a single render pass description to be used for both on-screen and off-screen targets. While Vulkan does allow a VkRenderPass to be used with any compatible frame buffer, and vkparse caches a VkRenderPass created from the same description, this allows the same description to be used for a compatible off-screen target without any dependence on the swapchain. However, there is a problem in the caching when it comes to targeting outputs with different formats.
2022-04-02 02:42:36 +00:00
static exprsym_t qfv_output_t_symbols[] = {
{"format", &VkFormat_type, (void *)field_offset (qfv_output_t, format)},
{"extent", &VkExtent2D_type, (void *)field_offset (qfv_output_t, extent)},
{"view", &VkImageView_type, (void *)field_offset (qfv_output_t, view)},
[vulkan] Provide access to swapchain image count This necessitated hand-writing qfv_swapchain_t's descriptors as I don't feel like getting that complicated with vkgen at this stage and it's not really appropriate anyway? qfv_swapchain_t is meant to be read-only and not parsed from a plist.
2021-01-09 16:38:31 +00:00
{ }
};
[vulkan] Break render pass parsing away from swapchain This allows a single render pass description to be used for both on-screen and off-screen targets. While Vulkan does allow a VkRenderPass to be used with any compatible frame buffer, and vkparse caches a VkRenderPass created from the same description, this allows the same description to be used for a compatible off-screen target without any dependence on the swapchain. However, there is a problem in the caching when it comes to targeting outputs with different formats.
2022-04-02 02:42:36 +00:00
static exprtab_t qfv_output_t_symtab = {
qfv_output_t_symbols,
[vulkan] Provide access to swapchain image count This necessitated hand-writing qfv_swapchain_t's descriptors as I don't feel like getting that complicated with vkgen at this stage and it's not really appropriate anyway? qfv_swapchain_t is meant to be read-only and not parsed from a plist.
2021-01-09 16:38:31 +00:00
};
[vulkan] Break render pass parsing away from swapchain This allows a single render pass description to be used for both on-screen and off-screen targets. While Vulkan does allow a VkRenderPass to be used with any compatible frame buffer, and vkparse caches a VkRenderPass created from the same description, this allows the same description to be used for a compatible off-screen target without any dependence on the swapchain. However, there is a problem in the caching when it comes to targeting outputs with different formats.
2022-04-02 02:42:36 +00:00
exprtype_t qfv_output_t_type = {
[cexpr] Require designated initializers for exprtype_t This will make expanding it much safer in the future.
2022-04-24 05:55:35 +00:00
.name = "qfv_output_t",
.size = sizeof (qfv_output_t),
.binops = cexpr_struct_binops,
.unops = 0,
.data = &qfv_output_t_symtab,
[vulkan] Provide access to swapchain image count This necessitated hand-writing qfv_swapchain_t's descriptors as I don't feel like getting that complicated with vkgen at this stage and it's not really appropriate anyway? qfv_swapchain_t is meant to be read-only and not parsed from a plist.
2021-01-09 16:38:31 +00:00
};
[vulkan] Rename vulkan_framebuffer_t It turns out I had conflated frame buffers with frames and wound up making a minor mess when separating the number of frames the renderer could have in flight from the number of swap-chain images. This is the first step towards correcting that mistake.
2021-02-05 01:22:32 +00:00
static exprsym_t vulkan_frameset_t_symbols[] = {
{"size", &cexpr_size_t, (void *)field_offset (vulkan_frameset_t, size)},
[vulkan] Make frame-buffer count available to It turns out I made a bit of a mistake in tying the frame-buffer count to the number of swapchain images. This is the first step in sorting that out.
2021-01-16 12:03:36 +00:00
{ }
};
[vulkan] Rename vulkan_framebuffer_t It turns out I had conflated frame buffers with frames and wound up making a minor mess when separating the number of frames the renderer could have in flight from the number of swap-chain images. This is the first step towards correcting that mistake.
2021-02-05 01:22:32 +00:00
static exprtab_t vulkan_frameset_t_symtab = {
vulkan_frameset_t_symbols,
[vulkan] Make frame-buffer count available to It turns out I made a bit of a mistake in tying the frame-buffer count to the number of swapchain images. This is the first step in sorting that out.
2021-01-16 12:03:36 +00:00
};
[vulkan] Rename vulkan_framebuffer_t It turns out I had conflated frame buffers with frames and wound up making a minor mess when separating the number of frames the renderer could have in flight from the number of swap-chain images. This is the first step towards correcting that mistake.
2021-02-05 01:22:32 +00:00
exprtype_t vulkan_frameset_t_type = {
[cexpr] Require designated initializers for exprtype_t This will make expanding it much safer in the future.
2022-04-24 05:55:35 +00:00
.name = "frameset",
.size = sizeof (vulkan_frameset_t *),
.binops = cexpr_struct_binops,
.unops = 0,
.data = &vulkan_frameset_t_symtab,
[vulkan] Make frame-buffer count available to It turns out I made a bit of a mistake in tying the frame-buffer count to the number of swapchain images. This is the first step in sorting that out.
2021-01-16 12:03:36 +00:00
};
[vulkan] Support multiple render passes Multiple render passes are needed for supporting shadow mapping, and this is a huge step towards breaking the Vulkan render free of Quake, and hopefully will lead the way for breaking the GL renderers free as well.
2021-12-02 12:58:29 +00:00
typedef struct {
[vulkan] Start work on scripted pipeline Nothing is actually done yet other than parsing the built-in property list to property list items (the actual parser is just a skeleton), but everything compiles
2020-07-16 06:42:49 +00:00
qfv_attachmentdescription_t *attachments;
qfv_subpassparametersset_t *subpasses;
qfv_subpassdependency_t *dependencies;
[vulkan] Support multiple render passes Multiple render passes are needed for supporting shadow mapping, and this is a huge step towards breaking the Vulkan render free of Quake, and hopefully will lead the way for breaking the GL renderers free as well.
2021-12-02 12:58:29 +00:00
} vkparse_renderpass_t;
[vulkan] Start work on scripted pipeline Nothing is actually done yet other than parsing the built-in property list to property list items (the actual parser is just a skeleton), but everything compiles
2020-07-16 06:42:49 +00:00
static plelement_t parse_qfv_renderpass_attachments_data = {
QFDictionary,
sizeof (VkAttachmentDescription),
Fix a pile of leaks and uninit errors Still "some" more to go: a pile to do with transforms and temporary entities, and a nasty one with host_cbuf. There's also all the static block-alloc lists :/
2021-03-21 10:56:17 +00:00
vkparse_alloc,
[vulkan] Start work on scripted pipeline Nothing is actually done yet other than parsing the built-in property list to property list items (the actual parser is just a skeleton), but everything compiles
2020-07-16 06:42:49 +00:00
parse_VkAttachmentDescription,
0,
};
static plelement_t parse_qfv_renderpass_subpasses_data = {
QFDictionary,
sizeof (VkSubpassDescription),
Fix a pile of leaks and uninit errors Still "some" more to go: a pile to do with transforms and temporary entities, and a nasty one with host_cbuf. There's also all the static block-alloc lists :/
2021-03-21 10:56:17 +00:00
vkparse_alloc,
[vulkan] Start work on scripted pipeline Nothing is actually done yet other than parsing the built-in property list to property list items (the actual parser is just a skeleton), but everything compiles
2020-07-16 06:42:49 +00:00
parse_VkSubpassDescription,
0,
};
static plelement_t parse_qfv_renderpass_dependencies_data = {
QFDictionary,
sizeof (VkSubpassDependency),
Fix a pile of leaks and uninit errors Still "some" more to go: a pile to do with transforms and temporary entities, and a nasty one with host_cbuf. There's also all the static block-alloc lists :/
2021-03-21 10:56:17 +00:00
vkparse_alloc,
[vulkan] Start work on scripted pipeline Nothing is actually done yet other than parsing the built-in property list to property list items (the actual parser is just a skeleton), but everything compiles
2020-07-16 06:42:49 +00:00
parse_VkSubpassDependency,
0,
};
static plfield_t renderpass_fields[] = {
[vulkan] Support multiple render passes Multiple render passes are needed for supporting shadow mapping, and this is a huge step towards breaking the Vulkan render free of Quake, and hopefully will lead the way for breaking the GL renderers free as well.
2021-12-02 12:58:29 +00:00
{ "attachments", field_offset(vkparse_renderpass_t,attachments), QFArray,
[vulkan] Implement most of the parser This gets renderpass parsing almost working (not hooked up, though). The missing bits are support for expressions for flags (namely support for the | operator) and references (eg $swapchain.format). However, this shows that the basic concept for the parser is working.
2020-07-16 15:29:53 +00:00
PL_ParseArray, &parse_qfv_renderpass_attachments_data },
[vulkan] Support multiple render passes Multiple render passes are needed for supporting shadow mapping, and this is a huge step towards breaking the Vulkan render free of Quake, and hopefully will lead the way for breaking the GL renderers free as well.
2021-12-02 12:58:29 +00:00
{ "subpasses", field_offset(vkparse_renderpass_t,subpasses), QFArray,
[vulkan] Implement most of the parser This gets renderpass parsing almost working (not hooked up, though). The missing bits are support for expressions for flags (namely support for the | operator) and references (eg $swapchain.format). However, this shows that the basic concept for the parser is working.
2020-07-16 15:29:53 +00:00
PL_ParseArray, &parse_qfv_renderpass_subpasses_data },
[vulkan] Support multiple render passes Multiple render passes are needed for supporting shadow mapping, and this is a huge step towards breaking the Vulkan render free of Quake, and hopefully will lead the way for breaking the GL renderers free as well.
2021-12-02 12:58:29 +00:00
{ "dependencies", field_offset(vkparse_renderpass_t,dependencies), QFArray,
[vulkan] Implement most of the parser This gets renderpass parsing almost working (not hooked up, though). The missing bits are support for expressions for flags (namely support for the | operator) and references (eg $swapchain.format). However, this shows that the basic concept for the parser is working.
2020-07-16 15:29:53 +00:00
PL_ParseArray, &parse_qfv_renderpass_dependencies_data },
[vulkan] Start work on scripted pipeline Nothing is actually done yet other than parsing the built-in property list to property list items (the actual parser is just a skeleton), but everything compiles
2020-07-16 06:42:49 +00:00
{}
};
[vulkan] Parse sampler definitions
2021-01-10 06:50:24 +00:00
static hashtab_t *
handlref_symtab (void (*free_func)(void*,void*), vulkan_ctx_t *ctx)
{
[hash] Rename the publicly visible hashlink_t to hashctx_t I think my biggest problem with the hashlink freelist parameter was how much implementation it exposed in just the name.
2022-05-12 08:54:23 +00:00
return Hash_NewTable (23, handleref_getkey, free_func, ctx, &ctx->hashctx);
[vulkan] Parse sampler definitions
2021-01-10 06:50:24 +00:00
}
[vulkan] Implement pipeline creation The prototypes for handle parsers needed to be changes because it turned out "single" was inappropriate for handles as "single" allocates memory for the parsed object, but handles must be written directly.
2021-01-05 14:42:30 +00:00
static const char *
enum_symtab_getkey (const void *e, void *unused)
{
__auto_type enm = (const exprenum_t *) e;
return enm->type->name;
}
[vulkan] Connect up the cexpr library This will make property list expressions easier to work with. The library is rather limited right now (trig, dot, min/max/bound) but even just min adds a lot of functionality.
2021-12-04 05:09:57 +00:00
static exprtab_t root_symtab = {
.symbols = cexpr_lib_symbols,
};
static void __attribute__((constructor))
root_symtab_init (void)
{
[hash] Rename the publicly visible hashlink_t to hashctx_t I think my biggest problem with the hashlink freelist parameter was how much implementation it exposed in just the name.
2022-05-12 08:54:23 +00:00
// using a null hashctx here is safe because this function is run before
[vulkan] Connect up the cexpr library This will make property list expressions easier to work with. The library is rather limited right now (trig, dot, min/max/bound) but even just min adds a lot of functionality.
2021-12-04 05:09:57 +00:00
// main and thus before any possibility of threading.
exprctx_t root_context = { .symtab = &root_symtab };
cexpr_init_symtab (&root_symtab, &root_context);
}
[vulkan] Implement pipeline creation The prototypes for handle parsers needed to be changes because it turned out "single" was inappropriate for handles as "single" allocates memory for the parsed object, but handles must be written directly.
2021-01-05 14:42:30 +00:00
void
QFV_InitParse (vulkan_ctx_t *ctx)
{
exprctx_t context = {};
[hash] Rename the publicly visible hashlink_t to hashctx_t I think my biggest problem with the hashlink freelist parameter was how much implementation it exposed in just the name.
2022-05-12 08:54:23 +00:00
enum_symtab = Hash_NewTable (61, enum_symtab_getkey, 0, 0, &ctx->hashctx);
context.hashctx = &ctx->hashctx;
[vulkan] Implement pipeline creation The prototypes for handle parsers needed to be changes because it turned out "single" was inappropriate for handles as "single" allocates memory for the parsed object, but handles must be written directly.
2021-01-05 14:42:30 +00:00
vkgen_init_symtabs (&context);
[vulkan] Break render pass parsing away from swapchain This allows a single render pass description to be used for both on-screen and off-screen targets. While Vulkan does allow a VkRenderPass to be used with any compatible frame buffer, and vkparse caches a VkRenderPass created from the same description, this allows the same description to be used for a compatible off-screen target without any dependence on the swapchain. However, there is a problem in the caching when it comes to targeting outputs with different formats.
2022-04-02 02:42:36 +00:00
cexpr_init_symtab (&qfv_output_t_symtab, &context);
[vulkan] Rename vulkan_framebuffer_t It turns out I had conflated frame buffers with frames and wound up making a minor mess when separating the number of frames the renderer could have in flight from the number of swap-chain images. This is the first step towards correcting that mistake.
2021-02-05 01:22:32 +00:00
cexpr_init_symtab (&vulkan_frameset_t_symtab, &context);
[vulkan] Ease writing of specialization data While using binary data objects for specialization data works for bools (as they can be 0 or -1), they don't work so well for numeric values due to having to get the byte order correct and thus are not portable, and difficult to get right. Binary data is still supported, but the data can be written as a string with an array(...) "constructor" expression taking any number of parameters, with each parameter itself being an expression (though values are limited at this stage). Due to the plist format, quotes are required around the expression ("array(...)")
2021-12-01 05:49:23 +00:00
cexpr_init_symtab (&data_array_symtab, &context);
[vulkan] Rework pipeline parsing for better reuse It's not entirely there yet, but the basics are working. Work is still needed for avoiding duplication of objects (different threads will have different contexts and thus different tables, so necessary per-thread duplication should not become a problem) and general access to arbitrary fields (mostly just parsing the strings)
2021-02-04 08:03:49 +00:00
if (!ctx->setLayouts) {
ctx->shaderModules = handlref_symtab (shaderModule_free, ctx);
ctx->setLayouts = handlref_symtab (setLayout_free, ctx);
ctx->pipelineLayouts = handlref_symtab (pipelineLayout_free, ctx);
ctx->descriptorPools = handlref_symtab (descriptorPool_free, ctx);
ctx->samplers = handlref_symtab (sampler_free, ctx);
[vulkan] Start moving towards a deferred renderer After getting lights even vaguely working for alias models, I realized that it just wasn't going to be feasible to do nice lighting with forward rendering. This gets the bulk of the work done for deferred rendering, but still need to sort out the shaders before any real testing can be done.
2021-02-14 02:35:06 +00:00
ctx->images = handlref_symtab (image_free, ctx);
ctx->imageViews = handlref_symtab (imageView_free, ctx);
[vulkan] Parse clear values And get the render pass working in general. Note that this is only the render pass and frame buffers: actual commands still have problems.
2021-02-23 05:37:48 +00:00
ctx->renderpasses = handlref_symtab (renderpass_free, ctx);
[vulkan] Rework pipeline parsing for better reuse It's not entirely there yet, but the basics are working. Work is still needed for avoiding duplication of objects (different threads will have different contexts and thus different tables, so necessary per-thread duplication should not become a problem) and general access to arbitrary fields (mostly just parsing the strings)
2021-02-04 08:03:49 +00:00
}
[vulkan] Implement pipeline creation The prototypes for handle parsers needed to be changes because it turned out "single" was inappropriate for handles as "single" allocates memory for the parsed object, but handles must be written directly.
2021-01-05 14:42:30 +00:00
}
exprenum_t *
QFV_GetEnum (const char *name)
{
return Hash_Find (enum_symtab, name);
}
[vulkan] Rework pipeline parsing for better reuse It's not entirely there yet, but the basics are working. Work is still needed for avoiding duplication of objects (different threads will have different contexts and thus different tables, so necessary per-thread duplication should not become a problem) and general access to arbitrary fields (mostly just parsing the strings)
2021-02-04 08:03:49 +00:00
static int
Fix a pile of leaks and uninit errors Still "some" more to go: a pile to do with transforms and temporary entities, and a nasty one with host_cbuf. There's also all the static block-alloc lists :/
2021-03-21 10:56:17 +00:00
parse_object (vulkan_ctx_t *ctx, memsuper_t *memsuper, plitem_t *plist,
[vulkan] Start moving towards a deferred renderer After getting lights even vaguely working for alias models, I realized that it just wasn't going to be feasible to do nice lighting with forward rendering. This gets the bulk of the work done for deferred rendering, but still need to sort out the shaders before any real testing can be done.
2021-02-14 02:35:06 +00:00
plparser_t parser, void *object, plitem_t *properties)
[vulkan] Start work on scripted pipeline Nothing is actually done yet other than parsing the built-in property list to property list items (the actual parser is just a skeleton), but everything compiles
2020-07-16 06:42:49 +00:00
{
plitem_t *messages = PL_NewArray ();
[vulkan] Connect up the cexpr library This will make property list expressions easier to work with. The library is rather limited right now (trig, dot, min/max/bound) but even just min adds a lot of functionality.
2021-12-04 05:09:57 +00:00
exprctx_t exprctx = { .symtab = &root_symtab };
[vulkan] Start moving towards a deferred renderer After getting lights even vaguely working for alias models, I realized that it just wasn't going to be feasible to do nice lighting with forward rendering. This gets the bulk of the work done for deferred rendering, but still need to sort out the shaders before any real testing can be done.
2021-02-14 02:35:06 +00:00
parsectx_t parsectx = { &exprctx, ctx, properties };
[vulkan] Hook up the expression parser The pipeline parser still isn't hooked up yet as something isn't quite right, but it seems all the parsing works.
2020-12-21 09:38:31 +00:00
exprsym_t var_syms[] = {
[vulkan] Break render pass parsing away from swapchain This allows a single render pass description to be used for both on-screen and off-screen targets. While Vulkan does allow a VkRenderPass to be used with any compatible frame buffer, and vkparse caches a VkRenderPass created from the same description, this allows the same description to be used for a compatible off-screen target without any dependence on the swapchain. However, there is a problem in the caching when it comes to targeting outputs with different formats.
2022-04-02 02:42:36 +00:00
{"output", &qfv_output_t_type, &ctx->output},
[vulkan] Rename vulkan_framebuffer_t It turns out I had conflated frame buffers with frames and wound up making a minor mess when separating the number of frames the renderer could have in flight from the number of swap-chain images. This is the first step towards correcting that mistake.
2021-02-05 01:22:32 +00:00
{"frames", &vulkan_frameset_t_type, &ctx->frames},
[vulkan] Ensure msaa settings are consistent I had forgotten that msaa samples was governed by the driver (as a max) and the renderpass setup code simply took the max. Thus why 1 vs 8 caused the display to render incorrectly.
2020-12-21 11:17:27 +00:00
{"msaaSamples", &VkSampleCountFlagBits_type, &ctx->msaaSamples},
[vulkan] Provide access to VkPhysicalDeviceLimits Fixes the warning about parse_fixed_array not being used (oops, the problem with partial commits), but more importantly, gives access to things like maxDescriptorSetSamplers.
2021-12-04 05:31:39 +00:00
{"physDevLimits", &VkPhysicalDeviceLimits_type,
&ctx->device->physDev->properties.limits },
[vulkan] Start moving towards a deferred renderer After getting lights even vaguely working for alias models, I realized that it just wasn't going to be feasible to do nice lighting with forward rendering. This gets the bulk of the work done for deferred rendering, but still need to sort out the shaders before any real testing can be done.
2021-02-14 02:35:06 +00:00
{QFV_PROPERTIES, &cexpr_plitem, &parsectx.properties},
[vulkan] Hook up the expression parser The pipeline parser still isn't hooked up yet as something isn't quite right, but it seems all the parsing works.
2020-12-21 09:38:31 +00:00
{}
};
exprtab_t vars_tab = { var_syms, 0 };
[vulkan] Rework pipeline parsing for better reuse It's not entirely there yet, but the basics are working. Work is still needed for avoiding duplication of objects (different threads will have different contexts and thus different tables, so necessary per-thread duplication should not become a problem) and general access to arbitrary fields (mostly just parsing the strings)
2021-02-04 08:03:49 +00:00
exprctx.external_variables = &vars_tab;
[vulkan] Hook up the expression parser The pipeline parser still isn't hooked up yet as something isn't quite right, but it seems all the parsing works.
2020-12-21 09:38:31 +00:00
exprctx.messages = messages;
[hash] Rename the publicly visible hashlink_t to hashctx_t I think my biggest problem with the hashlink freelist parameter was how much implementation it exposed in just the name.
2022-05-12 08:54:23 +00:00
exprctx.hashctx = &ctx->hashctx;
Fix a pile of leaks and uninit errors Still "some" more to go: a pile to do with transforms and temporary entities, and a nasty one with host_cbuf. There's also all the static block-alloc lists :/
2021-03-21 10:56:17 +00:00
exprctx.memsuper = memsuper;
[vulkan] Rework pipeline parsing for better reuse It's not entirely there yet, but the basics are working. Work is still needed for avoiding duplication of objects (different threads will have different contexts and thus different tables, so necessary per-thread duplication should not become a problem) and general access to arbitrary fields (mostly just parsing the strings)
2021-02-04 08:03:49 +00:00
[vulkan] Hook up the expression parser The pipeline parser still isn't hooked up yet as something isn't quite right, but it seems all the parsing works.
2020-12-21 09:38:31 +00:00
cexpr_init_symtab (&vars_tab, &exprctx);
[vulkan] Start work on scripted pipeline Nothing is actually done yet other than parsing the built-in property list to property list items (the actual parser is just a skeleton), but everything compiles
2020-07-16 06:42:49 +00:00
[vulkan] Rework pipeline parsing for better reuse It's not entirely there yet, but the basics are working. Work is still needed for avoiding duplication of objects (different threads will have different contexts and thus different tables, so necessary per-thread duplication should not become a problem) and general access to arbitrary fields (mostly just parsing the strings)
2021-02-04 08:03:49 +00:00
if (!parser (0, plist, object, messages, &parsectx)) {
[vulkan] Start work on scripted pipeline Nothing is actually done yet other than parsing the built-in property list to property list items (the actual parser is just a skeleton), but everything compiles
2020-07-16 06:42:49 +00:00
for (int i = 0; i < PL_A_NumObjects (messages); i++) {
[vulkan] Fix a couple of minor issues Magic number for compose descriptors and mistaken masking of vulkan plist parse errors.
2021-04-18 11:41:08 +00:00
Sys_Printf ("%s\n", PL_String (PL_ObjectAtIndex (messages, i)));
[vulkan] Start work on scripted pipeline Nothing is actually done yet other than parsing the built-in property list to property list items (the actual parser is just a skeleton), but everything compiles
2020-07-16 06:42:49 +00:00
}
return 0;
}
Fix a pile of leaks and uninit errors Still "some" more to go: a pile to do with transforms and temporary entities, and a nasty one with host_cbuf. There's also all the static block-alloc lists :/
2021-03-21 10:56:17 +00:00
Hash_DelTable (vars_tab.tab);
[vulkan] Start work on scripted pipeline Nothing is actually done yet other than parsing the built-in property list to property list items (the actual parser is just a skeleton), but everything compiles
2020-07-16 06:42:49 +00:00
PL_Free (messages);
[vulkan] Hook up the expression parser The pipeline parser still isn't hooked up yet as something isn't quite right, but it seems all the parsing works.
2020-12-21 09:38:31 +00:00
[vulkan] Rework pipeline parsing for better reuse It's not entirely there yet, but the basics are working. Work is still needed for avoiding duplication of objects (different threads will have different contexts and thus different tables, so necessary per-thread duplication should not become a problem) and general access to arbitrary fields (mostly just parsing the strings)
2021-02-04 08:03:49 +00:00
return 1;
}
static int
parse_qfv_renderpass (const plfield_t *field, const plitem_t *item, void *data,
plitem_t *messages, void *context)
{
return PL_ParseStruct (renderpass_fields, item, data, messages, context);
}
VkRenderPass
[vulkan] Start moving towards a deferred renderer After getting lights even vaguely working for alias models, I realized that it just wasn't going to be feasible to do nice lighting with forward rendering. This gets the bulk of the work done for deferred rendering, but still need to sort out the shaders before any real testing can be done.
2021-02-14 02:35:06 +00:00
QFV_ParseRenderPass (vulkan_ctx_t *ctx, plitem_t *plist, plitem_t *properties)
[vulkan] Rework pipeline parsing for better reuse It's not entirely there yet, but the basics are working. Work is still needed for avoiding duplication of objects (different threads will have different contexts and thus different tables, so necessary per-thread duplication should not become a problem) and general access to arbitrary fields (mostly just parsing the strings)
2021-02-04 08:03:49 +00:00
{
Fix a pile of leaks and uninit errors Still "some" more to go: a pile to do with transforms and temporary entities, and a nasty one with host_cbuf. There's also all the static block-alloc lists :/
2021-03-21 10:56:17 +00:00
memsuper_t *memsuper = new_memsuper ();
[vulkan] Rework pipeline parsing for better reuse It's not entirely there yet, but the basics are working. Work is still needed for avoiding duplication of objects (different threads will have different contexts and thus different tables, so necessary per-thread duplication should not become a problem) and general access to arbitrary fields (mostly just parsing the strings)
2021-02-04 08:03:49 +00:00
qfv_device_t *device = ctx->device;
[vulkan] Support multiple render passes Multiple render passes are needed for supporting shadow mapping, and this is a huge step towards breaking the Vulkan render free of Quake, and hopefully will lead the way for breaking the GL renderers free as well.
2021-12-02 12:58:29 +00:00
vkparse_renderpass_t renderpass_data = {};
[vulkan] Rework pipeline parsing for better reuse It's not entirely there yet, but the basics are working. Work is still needed for avoiding duplication of objects (different threads will have different contexts and thus different tables, so necessary per-thread duplication should not become a problem) and general access to arbitrary fields (mostly just parsing the strings)
2021-02-04 08:03:49 +00:00
Fix a pile of leaks and uninit errors Still "some" more to go: a pile to do with transforms and temporary entities, and a nasty one with host_cbuf. There's also all the static block-alloc lists :/
2021-03-21 10:56:17 +00:00
if (!parse_object (ctx, memsuper, plist, parse_qfv_renderpass,
&renderpass_data, properties)) {
delete_memsuper (memsuper);
[vulkan] Rework pipeline parsing for better reuse It's not entirely there yet, but the basics are working. Work is still needed for avoiding duplication of objects (different threads will have different contexts and thus different tables, so necessary per-thread duplication should not become a problem) and general access to arbitrary fields (mostly just parsing the strings)
2021-02-04 08:03:49 +00:00
return 0;
}
VkRenderPass renderpass;
[vulkan] Add a debug stack to the vulkan instance The stack is arbitrary strings that the validation layer debug callback prints in reverse order after each message. This makes it easy to work out what nodes in a pipeline/render pass plist are causing validation errors. Still have to narrow down the actual line, but the messages seem to help with that. Putting qfvPushDebug/qfvPopDebug around other calls to vulkan should help out a lot, tool. As a bonus, the stack is printed before debug_breakpoint is called, so it's immediately visible in gdb.
2021-11-30 03:24:45 +00:00
qfvPushDebug (ctx, va (ctx->va_ctx, "QFV_ParseRenderPass: %d", PL_Line (plist)));
[vulkan] Start work on scripted pipeline Nothing is actually done yet other than parsing the built-in property list to property list items (the actual parser is just a skeleton), but everything compiles
2020-07-16 06:42:49 +00:00
renderpass = QFV_CreateRenderPass (device,
renderpass_data.attachments,
renderpass_data.subpasses,
renderpass_data.dependencies);
[vulkan] Add a debug stack to the vulkan instance The stack is arbitrary strings that the validation layer debug callback prints in reverse order after each message. This makes it easy to work out what nodes in a pipeline/render pass plist are causing validation errors. Still have to narrow down the actual line, but the messages seem to help with that. Putting qfvPushDebug/qfvPopDebug around other calls to vulkan should help out a lot, tool. As a bonus, the stack is printed before debug_breakpoint is called, so it's immediately visible in gdb.
2021-11-30 03:24:45 +00:00
qfvPopDebug (ctx);
[vulkan] Start work on scripted pipeline Nothing is actually done yet other than parsing the built-in property list to property list items (the actual parser is just a skeleton), but everything compiles
2020-07-16 06:42:49 +00:00
Fix a pile of leaks and uninit errors Still "some" more to go: a pile to do with transforms and temporary entities, and a nasty one with host_cbuf. There's also all the static block-alloc lists :/
2021-03-21 10:56:17 +00:00
delete_memsuper (memsuper);
[vulkan] Start work on scripted pipeline Nothing is actually done yet other than parsing the built-in property list to property list items (the actual parser is just a skeleton), but everything compiles
2020-07-16 06:42:49 +00:00
return renderpass;
[vulkan] Rework pipeline parsing for better reuse It's not entirely there yet, but the basics are working. Work is still needed for avoiding duplication of objects (different threads will have different contexts and thus different tables, so necessary per-thread duplication should not become a problem) and general access to arbitrary fields (mostly just parsing the strings)
2021-02-04 08:03:49 +00:00
}
VkPipeline
[vulkan] Add support for compute shaders This needed changing Vulkan_CreatePipeline to Vulkan_CreateGraphicsPipeline for consistency (and parsing the difference from a plist seemed... not worth thinking about).
2021-12-16 14:00:17 +00:00
QFV_ParseComputePipeline (vulkan_ctx_t *ctx, plitem_t *plist,
plitem_t *properties)
{
memsuper_t *memsuper = new_memsuper ();
qfv_device_t *device = ctx->device;
__auto_type cInfo = QFV_AllocComputePipelineCreateInfoSet (1, alloca);
memset (&cInfo->a[0], 0, sizeof (cInfo->a[0]));
if (!parse_object (ctx, memsuper, plist, parse_VkComputePipelineCreateInfo,
&cInfo->a[0], properties)) {
delete_memsuper (memsuper);
return 0;
}
qfvPushDebug (ctx, va (ctx->va_ctx,
"QFV_ParseComputePipeline: %d", PL_Line (plist)));
__auto_type plSet = QFV_CreateComputePipelines (device, 0, cInfo);
qfvPopDebug (ctx);
VkPipeline pipeline = plSet->a[0];
free (plSet);
delete_memsuper (memsuper);
return pipeline;
}
VkPipeline
QFV_ParseGraphicsPipeline (vulkan_ctx_t *ctx, plitem_t *plist,
plitem_t *properties)
[vulkan] Rework pipeline parsing for better reuse It's not entirely there yet, but the basics are working. Work is still needed for avoiding duplication of objects (different threads will have different contexts and thus different tables, so necessary per-thread duplication should not become a problem) and general access to arbitrary fields (mostly just parsing the strings)
2021-02-04 08:03:49 +00:00
{
Fix a pile of leaks and uninit errors Still "some" more to go: a pile to do with transforms and temporary entities, and a nasty one with host_cbuf. There's also all the static block-alloc lists :/
2021-03-21 10:56:17 +00:00
memsuper_t *memsuper = new_memsuper ();
[vulkan] Rework pipeline parsing for better reuse It's not entirely there yet, but the basics are working. Work is still needed for avoiding duplication of objects (different threads will have different contexts and thus different tables, so necessary per-thread duplication should not become a problem) and general access to arbitrary fields (mostly just parsing the strings)
2021-02-04 08:03:49 +00:00
qfv_device_t *device = ctx->device;
__auto_type cInfo = QFV_AllocGraphicsPipelineCreateInfoSet (1, alloca);
memset (&cInfo->a[0], 0, sizeof (cInfo->a[0]));
Fix a pile of leaks and uninit errors Still "some" more to go: a pile to do with transforms and temporary entities, and a nasty one with host_cbuf. There's also all the static block-alloc lists :/
2021-03-21 10:56:17 +00:00
if (!parse_object (ctx, memsuper, plist, parse_VkGraphicsPipelineCreateInfo,
[vulkan] Start moving towards a deferred renderer After getting lights even vaguely working for alias models, I realized that it just wasn't going to be feasible to do nice lighting with forward rendering. This gets the bulk of the work done for deferred rendering, but still need to sort out the shaders before any real testing can be done.
2021-02-14 02:35:06 +00:00
&cInfo->a[0], properties)) {
Fix a pile of leaks and uninit errors Still "some" more to go: a pile to do with transforms and temporary entities, and a nasty one with host_cbuf. There's also all the static block-alloc lists :/
2021-03-21 10:56:17 +00:00
delete_memsuper (memsuper);
[vulkan] Rework pipeline parsing for better reuse It's not entirely there yet, but the basics are working. Work is still needed for avoiding duplication of objects (different threads will have different contexts and thus different tables, so necessary per-thread duplication should not become a problem) and general access to arbitrary fields (mostly just parsing the strings)
2021-02-04 08:03:49 +00:00
return 0;
}
[vulkan] Support multiple render passes Multiple render passes are needed for supporting shadow mapping, and this is a huge step towards breaking the Vulkan render free of Quake, and hopefully will lead the way for breaking the GL renderers free as well.
2021-12-02 12:58:29 +00:00
qfvPushDebug (ctx, va (ctx->va_ctx,
"QFV_ParsePipeline: %d", PL_Line (plist)));
[vulkan] Implement pipeline creation The prototypes for handle parsers needed to be changes because it turned out "single" was inappropriate for handles as "single" allocates memory for the parsed object, but handles must be written directly.
2021-01-05 14:42:30 +00:00
__auto_type plSet = QFV_CreateGraphicsPipelines (device, 0, cInfo);
[vulkan] Add a debug stack to the vulkan instance The stack is arbitrary strings that the validation layer debug callback prints in reverse order after each message. This makes it easy to work out what nodes in a pipeline/render pass plist are causing validation errors. Still have to narrow down the actual line, but the messages seem to help with that. Putting qfvPushDebug/qfvPopDebug around other calls to vulkan should help out a lot, tool. As a bonus, the stack is printed before debug_breakpoint is called, so it's immediately visible in gdb.
2021-11-30 03:24:45 +00:00
qfvPopDebug (ctx);
[vulkan] Implement pipeline creation The prototypes for handle parsers needed to be changes because it turned out "single" was inappropriate for handles as "single" allocates memory for the parsed object, but handles must be written directly.
2021-01-05 14:42:30 +00:00
VkPipeline pipeline = plSet->a[0];
free (plSet);
Fix a pile of leaks and uninit errors Still "some" more to go: a pile to do with transforms and temporary entities, and a nasty one with host_cbuf. There's also all the static block-alloc lists :/
2021-03-21 10:56:17 +00:00
delete_memsuper (memsuper);
[vulkan] Implement pipeline creation The prototypes for handle parsers needed to be changes because it turned out "single" was inappropriate for handles as "single" allocates memory for the parsed object, but handles must be written directly.
2021-01-05 14:42:30 +00:00
return pipeline;
[vulkan] Clean up some tangled dependencies Dependencies on vkparse.hinc were spreading through the code which I didn't want as that removes a lot of the automation from the automake files. This keeps all parser code internal to vkparse.c's scope, and any accesses required for enum and struct (not yet) definitions can be fetched by name.
2021-01-04 08:26:39 +00:00
}
[vulkan] Rework pipeline parsing for better reuse It's not entirely there yet, but the basics are working. Work is still needed for avoiding duplication of objects (different threads will have different contexts and thus different tables, so necessary per-thread duplication should not become a problem) and general access to arbitrary fields (mostly just parsing the strings)
2021-02-04 08:03:49 +00:00
VkDescriptorPool
[vulkan] Start moving towards a deferred renderer After getting lights even vaguely working for alias models, I realized that it just wasn't going to be feasible to do nice lighting with forward rendering. This gets the bulk of the work done for deferred rendering, but still need to sort out the shaders before any real testing can be done.
2021-02-14 02:35:06 +00:00
QFV_ParseDescriptorPool (vulkan_ctx_t *ctx, plitem_t *plist,
plitem_t *properties)
[vulkan] Rework pipeline parsing for better reuse It's not entirely there yet, but the basics are working. Work is still needed for avoiding duplication of objects (different threads will have different contexts and thus different tables, so necessary per-thread duplication should not become a problem) and general access to arbitrary fields (mostly just parsing the strings)
2021-02-04 08:03:49 +00:00
{
qfv_device_t *device = ctx->device;
qfv_devfuncs_t *dfunc = device->funcs;
Fix a pile of leaks and uninit errors Still "some" more to go: a pile to do with transforms and temporary entities, and a nasty one with host_cbuf. There's also all the static block-alloc lists :/
2021-03-21 10:56:17 +00:00
memsuper_t *memsuper = new_memsuper ();
[vulkan] Rework pipeline parsing for better reuse It's not entirely there yet, but the basics are working. Work is still needed for avoiding duplication of objects (different threads will have different contexts and thus different tables, so necessary per-thread duplication should not become a problem) and general access to arbitrary fields (mostly just parsing the strings)
2021-02-04 08:03:49 +00:00
VkDescriptorPoolCreateInfo cInfo = {};
Fix a pile of leaks and uninit errors Still "some" more to go: a pile to do with transforms and temporary entities, and a nasty one with host_cbuf. There's also all the static block-alloc lists :/
2021-03-21 10:56:17 +00:00
if (!parse_object (ctx, memsuper, plist, parse_VkDescriptorPoolCreateInfo,
&cInfo, properties)) {
delete_memsuper (memsuper);
[vulkan] Rework pipeline parsing for better reuse It's not entirely there yet, but the basics are working. Work is still needed for avoiding duplication of objects (different threads will have different contexts and thus different tables, so necessary per-thread duplication should not become a problem) and general access to arbitrary fields (mostly just parsing the strings)
2021-02-04 08:03:49 +00:00
return 0;
}
VkDescriptorPool pool;
[vulkan] Add a debug stack to the vulkan instance The stack is arbitrary strings that the validation layer debug callback prints in reverse order after each message. This makes it easy to work out what nodes in a pipeline/render pass plist are causing validation errors. Still have to narrow down the actual line, but the messages seem to help with that. Putting qfvPushDebug/qfvPopDebug around other calls to vulkan should help out a lot, tool. As a bonus, the stack is printed before debug_breakpoint is called, so it's immediately visible in gdb.
2021-11-30 03:24:45 +00:00
qfvPushDebug (ctx, va (ctx->va_ctx, "QFV_ParseDescriptorPool: %d", PL_Line (plist)));
[vulkan] Rework pipeline parsing for better reuse It's not entirely there yet, but the basics are working. Work is still needed for avoiding duplication of objects (different threads will have different contexts and thus different tables, so necessary per-thread duplication should not become a problem) and general access to arbitrary fields (mostly just parsing the strings)
2021-02-04 08:03:49 +00:00
dfunc->vkCreateDescriptorPool (device->dev, &cInfo, 0, &pool);
[vulkan] Add a debug stack to the vulkan instance The stack is arbitrary strings that the validation layer debug callback prints in reverse order after each message. This makes it easy to work out what nodes in a pipeline/render pass plist are causing validation errors. Still have to narrow down the actual line, but the messages seem to help with that. Putting qfvPushDebug/qfvPopDebug around other calls to vulkan should help out a lot, tool. As a bonus, the stack is printed before debug_breakpoint is called, so it's immediately visible in gdb.
2021-11-30 03:24:45 +00:00
qfvPopDebug (ctx);
[vulkan] Rework pipeline parsing for better reuse It's not entirely there yet, but the basics are working. Work is still needed for avoiding duplication of objects (different threads will have different contexts and thus different tables, so necessary per-thread duplication should not become a problem) and general access to arbitrary fields (mostly just parsing the strings)
2021-02-04 08:03:49 +00:00
Fix a pile of leaks and uninit errors Still "some" more to go: a pile to do with transforms and temporary entities, and a nasty one with host_cbuf. There's also all the static block-alloc lists :/
2021-03-21 10:56:17 +00:00
delete_memsuper (memsuper);
[vulkan] Rework pipeline parsing for better reuse It's not entirely there yet, but the basics are working. Work is still needed for avoiding duplication of objects (different threads will have different contexts and thus different tables, so necessary per-thread duplication should not become a problem) and general access to arbitrary fields (mostly just parsing the strings)
2021-02-04 08:03:49 +00:00
return pool;
}
VkDescriptorSetLayout
[vulkan] Start moving towards a deferred renderer After getting lights even vaguely working for alias models, I realized that it just wasn't going to be feasible to do nice lighting with forward rendering. This gets the bulk of the work done for deferred rendering, but still need to sort out the shaders before any real testing can be done.
2021-02-14 02:35:06 +00:00
QFV_ParseDescriptorSetLayout (vulkan_ctx_t *ctx, plitem_t *plist,
plitem_t *properties)
[vulkan] Rework pipeline parsing for better reuse It's not entirely there yet, but the basics are working. Work is still needed for avoiding duplication of objects (different threads will have different contexts and thus different tables, so necessary per-thread duplication should not become a problem) and general access to arbitrary fields (mostly just parsing the strings)
2021-02-04 08:03:49 +00:00
{
qfv_device_t *device = ctx->device;
qfv_devfuncs_t *dfunc = device->funcs;
Fix a pile of leaks and uninit errors Still "some" more to go: a pile to do with transforms and temporary entities, and a nasty one with host_cbuf. There's also all the static block-alloc lists :/
2021-03-21 10:56:17 +00:00
memsuper_t *memsuper = new_memsuper ();
[vulkan] Rework pipeline parsing for better reuse It's not entirely there yet, but the basics are working. Work is still needed for avoiding duplication of objects (different threads will have different contexts and thus different tables, so necessary per-thread duplication should not become a problem) and general access to arbitrary fields (mostly just parsing the strings)
2021-02-04 08:03:49 +00:00
VkDescriptorSetLayoutCreateInfo cInfo = {};
Fix a pile of leaks and uninit errors Still "some" more to go: a pile to do with transforms and temporary entities, and a nasty one with host_cbuf. There's also all the static block-alloc lists :/
2021-03-21 10:56:17 +00:00
if (!parse_object (ctx, memsuper, plist,
parse_VkDescriptorSetLayoutCreateInfo,
[vulkan] Start moving towards a deferred renderer After getting lights even vaguely working for alias models, I realized that it just wasn't going to be feasible to do nice lighting with forward rendering. This gets the bulk of the work done for deferred rendering, but still need to sort out the shaders before any real testing can be done.
2021-02-14 02:35:06 +00:00
&cInfo, properties)) {
Fix a pile of leaks and uninit errors Still "some" more to go: a pile to do with transforms and temporary entities, and a nasty one with host_cbuf. There's also all the static block-alloc lists :/
2021-03-21 10:56:17 +00:00
delete_memsuper (memsuper);
[vulkan] Rework pipeline parsing for better reuse It's not entirely there yet, but the basics are working. Work is still needed for avoiding duplication of objects (different threads will have different contexts and thus different tables, so necessary per-thread duplication should not become a problem) and general access to arbitrary fields (mostly just parsing the strings)
2021-02-04 08:03:49 +00:00
return 0;
}
VkDescriptorSetLayout setLayout;
[vulkan] Add a debug stack to the vulkan instance The stack is arbitrary strings that the validation layer debug callback prints in reverse order after each message. This makes it easy to work out what nodes in a pipeline/render pass plist are causing validation errors. Still have to narrow down the actual line, but the messages seem to help with that. Putting qfvPushDebug/qfvPopDebug around other calls to vulkan should help out a lot, tool. As a bonus, the stack is printed before debug_breakpoint is called, so it's immediately visible in gdb.
2021-11-30 03:24:45 +00:00
qfvPushDebug (ctx, va (ctx->va_ctx, "QFV_ParseDescriptorSetLayout: %d", PL_Line (plist)));
[vulkan] Rework pipeline parsing for better reuse It's not entirely there yet, but the basics are working. Work is still needed for avoiding duplication of objects (different threads will have different contexts and thus different tables, so necessary per-thread duplication should not become a problem) and general access to arbitrary fields (mostly just parsing the strings)
2021-02-04 08:03:49 +00:00
dfunc->vkCreateDescriptorSetLayout (device->dev, &cInfo, 0, &setLayout);
[vulkan] Name some more objects Shaders and descriptor set layouts.
2021-04-19 08:49:03 +00:00
QFV_duSetObjectName (device, VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT,
setLayout, va (ctx->va_ctx, "descriptorSetLayout:%d",
PL_Line (plist)));
[vulkan] Add a debug stack to the vulkan instance The stack is arbitrary strings that the validation layer debug callback prints in reverse order after each message. This makes it easy to work out what nodes in a pipeline/render pass plist are causing validation errors. Still have to narrow down the actual line, but the messages seem to help with that. Putting qfvPushDebug/qfvPopDebug around other calls to vulkan should help out a lot, tool. As a bonus, the stack is printed before debug_breakpoint is called, so it's immediately visible in gdb.
2021-11-30 03:24:45 +00:00
qfvPopDebug (ctx);
[vulkan] Rework pipeline parsing for better reuse It's not entirely there yet, but the basics are working. Work is still needed for avoiding duplication of objects (different threads will have different contexts and thus different tables, so necessary per-thread duplication should not become a problem) and general access to arbitrary fields (mostly just parsing the strings)
2021-02-04 08:03:49 +00:00
Fix a pile of leaks and uninit errors Still "some" more to go: a pile to do with transforms and temporary entities, and a nasty one with host_cbuf. There's also all the static block-alloc lists :/
2021-03-21 10:56:17 +00:00
delete_memsuper (memsuper);
[vulkan] Rework pipeline parsing for better reuse It's not entirely there yet, but the basics are working. Work is still needed for avoiding duplication of objects (different threads will have different contexts and thus different tables, so necessary per-thread duplication should not become a problem) and general access to arbitrary fields (mostly just parsing the strings)
2021-02-04 08:03:49 +00:00
return setLayout;
}
VkPipelineLayout
[vulkan] Start moving towards a deferred renderer After getting lights even vaguely working for alias models, I realized that it just wasn't going to be feasible to do nice lighting with forward rendering. This gets the bulk of the work done for deferred rendering, but still need to sort out the shaders before any real testing can be done.
2021-02-14 02:35:06 +00:00
QFV_ParsePipelineLayout (vulkan_ctx_t *ctx, plitem_t *plist,
plitem_t *properties)
[vulkan] Rework pipeline parsing for better reuse It's not entirely there yet, but the basics are working. Work is still needed for avoiding duplication of objects (different threads will have different contexts and thus different tables, so necessary per-thread duplication should not become a problem) and general access to arbitrary fields (mostly just parsing the strings)
2021-02-04 08:03:49 +00:00
{
qfv_device_t *device = ctx->device;
qfv_devfuncs_t *dfunc = device->funcs;
Fix a pile of leaks and uninit errors Still "some" more to go: a pile to do with transforms and temporary entities, and a nasty one with host_cbuf. There's also all the static block-alloc lists :/
2021-03-21 10:56:17 +00:00
memsuper_t *memsuper = new_memsuper ();
[vulkan] Rework pipeline parsing for better reuse It's not entirely there yet, but the basics are working. Work is still needed for avoiding duplication of objects (different threads will have different contexts and thus different tables, so necessary per-thread duplication should not become a problem) and general access to arbitrary fields (mostly just parsing the strings)
2021-02-04 08:03:49 +00:00
VkPipelineLayoutCreateInfo cInfo = {};
Fix a pile of leaks and uninit errors Still "some" more to go: a pile to do with transforms and temporary entities, and a nasty one with host_cbuf. There's also all the static block-alloc lists :/
2021-03-21 10:56:17 +00:00
if (!parse_object (ctx, memsuper, plist, parse_VkPipelineLayoutCreateInfo,
[vulkan] Start moving towards a deferred renderer After getting lights even vaguely working for alias models, I realized that it just wasn't going to be feasible to do nice lighting with forward rendering. This gets the bulk of the work done for deferred rendering, but still need to sort out the shaders before any real testing can be done.
2021-02-14 02:35:06 +00:00
&cInfo, properties)) {
Fix a pile of leaks and uninit errors Still "some" more to go: a pile to do with transforms and temporary entities, and a nasty one with host_cbuf. There's also all the static block-alloc lists :/
2021-03-21 10:56:17 +00:00
delete_memsuper (memsuper);
[vulkan] Rework pipeline parsing for better reuse It's not entirely there yet, but the basics are working. Work is still needed for avoiding duplication of objects (different threads will have different contexts and thus different tables, so necessary per-thread duplication should not become a problem) and general access to arbitrary fields (mostly just parsing the strings)
2021-02-04 08:03:49 +00:00
return 0;
}
VkPipelineLayout layout;
[vulkan] Add a debug stack to the vulkan instance The stack is arbitrary strings that the validation layer debug callback prints in reverse order after each message. This makes it easy to work out what nodes in a pipeline/render pass plist are causing validation errors. Still have to narrow down the actual line, but the messages seem to help with that. Putting qfvPushDebug/qfvPopDebug around other calls to vulkan should help out a lot, tool. As a bonus, the stack is printed before debug_breakpoint is called, so it's immediately visible in gdb.
2021-11-30 03:24:45 +00:00
qfvPushDebug (ctx, va (ctx->va_ctx, "QFV_ParsePipelineLayout: %d", PL_Line (plist)));
[vulkan] Rework pipeline parsing for better reuse It's not entirely there yet, but the basics are working. Work is still needed for avoiding duplication of objects (different threads will have different contexts and thus different tables, so necessary per-thread duplication should not become a problem) and general access to arbitrary fields (mostly just parsing the strings)
2021-02-04 08:03:49 +00:00
dfunc->vkCreatePipelineLayout (device->dev, &cInfo, 0, &layout);
[vulkan] Clean up misuse of va for vulkan handles The built up "path" name of the handle resource was not always surviving the intervening call to cexpr_eval_string (in particular, when other handles were created in the process of creating a handle). Rather than simply increase the number of va buffers (where would it end?), just regenerate the path when adding the new handle. It's probably quick enough, and the code is not usually not on a critical path.
2021-04-22 10:47:42 +00:00
QFV_duSetObjectName (device, VK_OBJECT_TYPE_PIPELINE_LAYOUT,
layout, va (ctx->va_ctx, "pipelineLayout:%d",
PL_Line (plist)));
[vulkan] Add a debug stack to the vulkan instance The stack is arbitrary strings that the validation layer debug callback prints in reverse order after each message. This makes it easy to work out what nodes in a pipeline/render pass plist are causing validation errors. Still have to narrow down the actual line, but the messages seem to help with that. Putting qfvPushDebug/qfvPopDebug around other calls to vulkan should help out a lot, tool. As a bonus, the stack is printed before debug_breakpoint is called, so it's immediately visible in gdb.
2021-11-30 03:24:45 +00:00
qfvPopDebug (ctx);
[vulkan] Rework pipeline parsing for better reuse It's not entirely there yet, but the basics are working. Work is still needed for avoiding duplication of objects (different threads will have different contexts and thus different tables, so necessary per-thread duplication should not become a problem) and general access to arbitrary fields (mostly just parsing the strings)
2021-02-04 08:03:49 +00:00
Fix a pile of leaks and uninit errors Still "some" more to go: a pile to do with transforms and temporary entities, and a nasty one with host_cbuf. There's also all the static block-alloc lists :/
2021-03-21 10:56:17 +00:00
delete_memsuper (memsuper);
[vulkan] Rework pipeline parsing for better reuse It's not entirely there yet, but the basics are working. Work is still needed for avoiding duplication of objects (different threads will have different contexts and thus different tables, so necessary per-thread duplication should not become a problem) and general access to arbitrary fields (mostly just parsing the strings)
2021-02-04 08:03:49 +00:00
return layout;
}
VkSampler
[vulkan] Start moving towards a deferred renderer After getting lights even vaguely working for alias models, I realized that it just wasn't going to be feasible to do nice lighting with forward rendering. This gets the bulk of the work done for deferred rendering, but still need to sort out the shaders before any real testing can be done.
2021-02-14 02:35:06 +00:00
QFV_ParseSampler (vulkan_ctx_t *ctx, plitem_t *plist, plitem_t *properties)
[vulkan] Rework pipeline parsing for better reuse It's not entirely there yet, but the basics are working. Work is still needed for avoiding duplication of objects (different threads will have different contexts and thus different tables, so necessary per-thread duplication should not become a problem) and general access to arbitrary fields (mostly just parsing the strings)
2021-02-04 08:03:49 +00:00
{
qfv_device_t *device = ctx->device;
qfv_devfuncs_t *dfunc = device->funcs;
Fix a pile of leaks and uninit errors Still "some" more to go: a pile to do with transforms and temporary entities, and a nasty one with host_cbuf. There's also all the static block-alloc lists :/
2021-03-21 10:56:17 +00:00
memsuper_t *memsuper = new_memsuper ();
[vulkan] Rework pipeline parsing for better reuse It's not entirely there yet, but the basics are working. Work is still needed for avoiding duplication of objects (different threads will have different contexts and thus different tables, so necessary per-thread duplication should not become a problem) and general access to arbitrary fields (mostly just parsing the strings)
2021-02-04 08:03:49 +00:00
VkSamplerCreateInfo cInfo = {};
Fix a pile of leaks and uninit errors Still "some" more to go: a pile to do with transforms and temporary entities, and a nasty one with host_cbuf. There's also all the static block-alloc lists :/
2021-03-21 10:56:17 +00:00
if (!parse_object (ctx, memsuper, plist, parse_VkSamplerCreateInfo, &cInfo,
[vulkan] Start moving towards a deferred renderer After getting lights even vaguely working for alias models, I realized that it just wasn't going to be feasible to do nice lighting with forward rendering. This gets the bulk of the work done for deferred rendering, but still need to sort out the shaders before any real testing can be done.
2021-02-14 02:35:06 +00:00
properties)) {
Fix a pile of leaks and uninit errors Still "some" more to go: a pile to do with transforms and temporary entities, and a nasty one with host_cbuf. There's also all the static block-alloc lists :/
2021-03-21 10:56:17 +00:00
delete_memsuper (memsuper);
[vulkan] Rework pipeline parsing for better reuse It's not entirely there yet, but the basics are working. Work is still needed for avoiding duplication of objects (different threads will have different contexts and thus different tables, so necessary per-thread duplication should not become a problem) and general access to arbitrary fields (mostly just parsing the strings)
2021-02-04 08:03:49 +00:00
return 0;
}
VkSampler sampler;
[vulkan] Add a debug stack to the vulkan instance The stack is arbitrary strings that the validation layer debug callback prints in reverse order after each message. This makes it easy to work out what nodes in a pipeline/render pass plist are causing validation errors. Still have to narrow down the actual line, but the messages seem to help with that. Putting qfvPushDebug/qfvPopDebug around other calls to vulkan should help out a lot, tool. As a bonus, the stack is printed before debug_breakpoint is called, so it's immediately visible in gdb.
2021-11-30 03:24:45 +00:00
qfvPushDebug (ctx, va (ctx->va_ctx, "QFV_ParseSampler: %d", PL_Line (plist)));
[vulkan] Rework pipeline parsing for better reuse It's not entirely there yet, but the basics are working. Work is still needed for avoiding duplication of objects (different threads will have different contexts and thus different tables, so necessary per-thread duplication should not become a problem) and general access to arbitrary fields (mostly just parsing the strings)
2021-02-04 08:03:49 +00:00
dfunc->vkCreateSampler (device->dev, &cInfo, 0, &sampler);
[vulkan] Add a debug stack to the vulkan instance The stack is arbitrary strings that the validation layer debug callback prints in reverse order after each message. This makes it easy to work out what nodes in a pipeline/render pass plist are causing validation errors. Still have to narrow down the actual line, but the messages seem to help with that. Putting qfvPushDebug/qfvPopDebug around other calls to vulkan should help out a lot, tool. As a bonus, the stack is printed before debug_breakpoint is called, so it's immediately visible in gdb.
2021-11-30 03:24:45 +00:00
qfvPopDebug (ctx);
[vulkan] Rework pipeline parsing for better reuse It's not entirely there yet, but the basics are working. Work is still needed for avoiding duplication of objects (different threads will have different contexts and thus different tables, so necessary per-thread duplication should not become a problem) and general access to arbitrary fields (mostly just parsing the strings)
2021-02-04 08:03:49 +00:00
Fix a pile of leaks and uninit errors Still "some" more to go: a pile to do with transforms and temporary entities, and a nasty one with host_cbuf. There's also all the static block-alloc lists :/
2021-03-21 10:56:17 +00:00
delete_memsuper (memsuper);
[vulkan] Rework pipeline parsing for better reuse It's not entirely there yet, but the basics are working. Work is still needed for avoiding duplication of objects (different threads will have different contexts and thus different tables, so necessary per-thread duplication should not become a problem) and general access to arbitrary fields (mostly just parsing the strings)
2021-02-04 08:03:49 +00:00
return sampler;
}
[vulkan] Start moving towards a deferred renderer After getting lights even vaguely working for alias models, I realized that it just wasn't going to be feasible to do nice lighting with forward rendering. This gets the bulk of the work done for deferred rendering, but still need to sort out the shaders before any real testing can be done.
2021-02-14 02:35:06 +00:00
VkImage
QFV_ParseImage (vulkan_ctx_t *ctx, plitem_t *plist, plitem_t *properties)
{
qfv_device_t *device = ctx->device;
qfv_devfuncs_t *dfunc = device->funcs;
Fix a pile of leaks and uninit errors Still "some" more to go: a pile to do with transforms and temporary entities, and a nasty one with host_cbuf. There's also all the static block-alloc lists :/
2021-03-21 10:56:17 +00:00
memsuper_t *memsuper = new_memsuper ();
[vulkan] Start moving towards a deferred renderer After getting lights even vaguely working for alias models, I realized that it just wasn't going to be feasible to do nice lighting with forward rendering. This gets the bulk of the work done for deferred rendering, but still need to sort out the shaders before any real testing can be done.
2021-02-14 02:35:06 +00:00
VkImageCreateInfo cInfo = {};
Fix a pile of leaks and uninit errors Still "some" more to go: a pile to do with transforms and temporary entities, and a nasty one with host_cbuf. There's also all the static block-alloc lists :/
2021-03-21 10:56:17 +00:00
if (!parse_object (ctx, memsuper, plist, parse_VkImageCreateInfo, &cInfo,
[vulkan] Start moving towards a deferred renderer After getting lights even vaguely working for alias models, I realized that it just wasn't going to be feasible to do nice lighting with forward rendering. This gets the bulk of the work done for deferred rendering, but still need to sort out the shaders before any real testing can be done.
2021-02-14 02:35:06 +00:00
properties)) {
Fix a pile of leaks and uninit errors Still "some" more to go: a pile to do with transforms and temporary entities, and a nasty one with host_cbuf. There's also all the static block-alloc lists :/
2021-03-21 10:56:17 +00:00
delete_memsuper (memsuper);
[vulkan] Start moving towards a deferred renderer After getting lights even vaguely working for alias models, I realized that it just wasn't going to be feasible to do nice lighting with forward rendering. This gets the bulk of the work done for deferred rendering, but still need to sort out the shaders before any real testing can be done.
2021-02-14 02:35:06 +00:00
return 0;
}
VkImage image;
[vulkan] Add a debug stack to the vulkan instance The stack is arbitrary strings that the validation layer debug callback prints in reverse order after each message. This makes it easy to work out what nodes in a pipeline/render pass plist are causing validation errors. Still have to narrow down the actual line, but the messages seem to help with that. Putting qfvPushDebug/qfvPopDebug around other calls to vulkan should help out a lot, tool. As a bonus, the stack is printed before debug_breakpoint is called, so it's immediately visible in gdb.
2021-11-30 03:24:45 +00:00
qfvPushDebug (ctx, va (ctx->va_ctx, "QFV_ParseImage: %d", PL_Line (plist)));
[vulkan] Start moving towards a deferred renderer After getting lights even vaguely working for alias models, I realized that it just wasn't going to be feasible to do nice lighting with forward rendering. This gets the bulk of the work done for deferred rendering, but still need to sort out the shaders before any real testing can be done.
2021-02-14 02:35:06 +00:00
dfunc->vkCreateImage (device->dev, &cInfo, 0, &image);
[vulkan] Add a debug stack to the vulkan instance The stack is arbitrary strings that the validation layer debug callback prints in reverse order after each message. This makes it easy to work out what nodes in a pipeline/render pass plist are causing validation errors. Still have to narrow down the actual line, but the messages seem to help with that. Putting qfvPushDebug/qfvPopDebug around other calls to vulkan should help out a lot, tool. As a bonus, the stack is printed before debug_breakpoint is called, so it's immediately visible in gdb.
2021-11-30 03:24:45 +00:00
qfvPopDebug (ctx);
[vulkan] Start moving towards a deferred renderer After getting lights even vaguely working for alias models, I realized that it just wasn't going to be feasible to do nice lighting with forward rendering. This gets the bulk of the work done for deferred rendering, but still need to sort out the shaders before any real testing can be done.
2021-02-14 02:35:06 +00:00
Fix a pile of leaks and uninit errors Still "some" more to go: a pile to do with transforms and temporary entities, and a nasty one with host_cbuf. There's also all the static block-alloc lists :/
2021-03-21 10:56:17 +00:00
delete_memsuper (memsuper);
[vulkan] Start moving towards a deferred renderer After getting lights even vaguely working for alias models, I realized that it just wasn't going to be feasible to do nice lighting with forward rendering. This gets the bulk of the work done for deferred rendering, but still need to sort out the shaders before any real testing can be done.
2021-02-14 02:35:06 +00:00
return image;
}
VkImageView
QFV_ParseImageView (vulkan_ctx_t *ctx, plitem_t *plist, plitem_t *properties)
{
qfv_device_t *device = ctx->device;
qfv_devfuncs_t *dfunc = device->funcs;
Fix a pile of leaks and uninit errors Still "some" more to go: a pile to do with transforms and temporary entities, and a nasty one with host_cbuf. There's also all the static block-alloc lists :/
2021-03-21 10:56:17 +00:00
memsuper_t *memsuper = new_memsuper ();
[vulkan] Start moving towards a deferred renderer After getting lights even vaguely working for alias models, I realized that it just wasn't going to be feasible to do nice lighting with forward rendering. This gets the bulk of the work done for deferred rendering, but still need to sort out the shaders before any real testing can be done.
2021-02-14 02:35:06 +00:00
VkImageViewCreateInfo cInfo = {};
Fix a pile of leaks and uninit errors Still "some" more to go: a pile to do with transforms and temporary entities, and a nasty one with host_cbuf. There's also all the static block-alloc lists :/
2021-03-21 10:56:17 +00:00
if (!parse_object (ctx, memsuper, plist, parse_VkImageViewCreateInfo,
&cInfo, properties)) {
delete_memsuper (memsuper);
[vulkan] Start moving towards a deferred renderer After getting lights even vaguely working for alias models, I realized that it just wasn't going to be feasible to do nice lighting with forward rendering. This gets the bulk of the work done for deferred rendering, but still need to sort out the shaders before any real testing can be done.
2021-02-14 02:35:06 +00:00
return 0;
}
VkImageView imageView;
[vulkan] Add a debug stack to the vulkan instance The stack is arbitrary strings that the validation layer debug callback prints in reverse order after each message. This makes it easy to work out what nodes in a pipeline/render pass plist are causing validation errors. Still have to narrow down the actual line, but the messages seem to help with that. Putting qfvPushDebug/qfvPopDebug around other calls to vulkan should help out a lot, tool. As a bonus, the stack is printed before debug_breakpoint is called, so it's immediately visible in gdb.
2021-11-30 03:24:45 +00:00
qfvPushDebug (ctx, va (ctx->va_ctx, "QFV_ParseImageView: %d", PL_Line (plist)));
[vulkan] Start moving towards a deferred renderer After getting lights even vaguely working for alias models, I realized that it just wasn't going to be feasible to do nice lighting with forward rendering. This gets the bulk of the work done for deferred rendering, but still need to sort out the shaders before any real testing can be done.
2021-02-14 02:35:06 +00:00
dfunc->vkCreateImageView (device->dev, &cInfo, 0, &imageView);
[vulkan] Add a debug stack to the vulkan instance The stack is arbitrary strings that the validation layer debug callback prints in reverse order after each message. This makes it easy to work out what nodes in a pipeline/render pass plist are causing validation errors. Still have to narrow down the actual line, but the messages seem to help with that. Putting qfvPushDebug/qfvPopDebug around other calls to vulkan should help out a lot, tool. As a bonus, the stack is printed before debug_breakpoint is called, so it's immediately visible in gdb.
2021-11-30 03:24:45 +00:00
qfvPopDebug (ctx);
[vulkan] Start moving towards a deferred renderer After getting lights even vaguely working for alias models, I realized that it just wasn't going to be feasible to do nice lighting with forward rendering. This gets the bulk of the work done for deferred rendering, but still need to sort out the shaders before any real testing can be done.
2021-02-14 02:35:06 +00:00
Fix a pile of leaks and uninit errors Still "some" more to go: a pile to do with transforms and temporary entities, and a nasty one with host_cbuf. There's also all the static block-alloc lists :/
2021-03-21 10:56:17 +00:00
delete_memsuper (memsuper);
[vulkan] Start moving towards a deferred renderer After getting lights even vaguely working for alias models, I realized that it just wasn't going to be feasible to do nice lighting with forward rendering. This gets the bulk of the work done for deferred rendering, but still need to sort out the shaders before any real testing can be done.
2021-02-14 02:35:06 +00:00
return imageView;
}
typedef struct {
uint32_t count;
VkImageCreateInfo *info;
} imagecreate_t;
typedef struct {
uint32_t count;
VkImageViewCreateInfo *info;
} imageviewcreate_t;
static plelement_t qfv_imagecreate_dict = {
QFDictionary,
sizeof (VkImageCreateInfo),
Fix a pile of leaks and uninit errors Still "some" more to go: a pile to do with transforms and temporary entities, and a nasty one with host_cbuf. There's also all the static block-alloc lists :/
2021-03-21 10:56:17 +00:00
vkparse_alloc,
[vulkan] Start moving towards a deferred renderer After getting lights even vaguely working for alias models, I realized that it just wasn't going to be feasible to do nice lighting with forward rendering. This gets the bulk of the work done for deferred rendering, but still need to sort out the shaders before any real testing can be done.
2021-02-14 02:35:06 +00:00
parse_VkImageCreateInfo,
};
static plelement_t qfv_imageviewcreate_dict = {
QFDictionary,
sizeof (VkImageViewCreateInfo),
Fix a pile of leaks and uninit errors Still "some" more to go: a pile to do with transforms and temporary entities, and a nasty one with host_cbuf. There's also all the static block-alloc lists :/
2021-03-21 10:56:17 +00:00
vkparse_alloc,
[vulkan] Start moving towards a deferred renderer After getting lights even vaguely working for alias models, I realized that it just wasn't going to be feasible to do nice lighting with forward rendering. This gets the bulk of the work done for deferred rendering, but still need to sort out the shaders before any real testing can be done.
2021-02-14 02:35:06 +00:00
parse_VkImageViewCreateInfo,
};
static int
parse_imagecreate_dict (const plfield_t *field, const plitem_t *item,
void *data, plitem_t *messages, void *context)
{
plfield_t f = { "images", 0, QFArray, parse_array,
&qfv_imagecreate_dict };
typedef struct arr_s DARRAY_TYPE(byte) arr_t;
arr_t *arr = 0;
int ret;
if ((ret = PL_ParseLabeledArray (&f, item, &arr, messages, context))) {
imagecreate_t *imagecreate = data;
imagecreate->count = arr->size;
imagecreate->info = (VkImageCreateInfo *) arr->a;
}
return ret;
}
static int
parse_imageviewcreate_dict (const plfield_t *field, const plitem_t *item,
void *data, plitem_t *messages, void *context)
{
plfield_t f = { "images", 0, QFArray, parse_array,
&qfv_imageviewcreate_dict };
typedef struct arr_s DARRAY_TYPE(byte) arr_t;
arr_t *arr = 0;
int ret;
if ((ret = PL_ParseLabeledArray (&f, item, &arr, messages, context))) {
imageviewcreate_t *imageviewcreate = data;
imageviewcreate->count = arr->size;
imageviewcreate->info = (VkImageViewCreateInfo *) arr->a;
} else {
//FIXME leaky boat when succeeds
if (arr) {
free (arr);
}
}
return ret;
}
qfv_imageset_t *
QFV_ParseImageSet (vulkan_ctx_t *ctx, plitem_t *item, plitem_t *properties)
{
qfv_device_t *device = ctx->device;
qfv_devfuncs_t *dfunc = device->funcs;
Fix a pile of leaks and uninit errors Still "some" more to go: a pile to do with transforms and temporary entities, and a nasty one with host_cbuf. There's also all the static block-alloc lists :/
2021-03-21 10:56:17 +00:00
memsuper_t *memsuper = new_memsuper ();
[vulkan] Start moving towards a deferred renderer After getting lights even vaguely working for alias models, I realized that it just wasn't going to be feasible to do nice lighting with forward rendering. This gets the bulk of the work done for deferred rendering, but still need to sort out the shaders before any real testing can be done.
2021-02-14 02:35:06 +00:00
imagecreate_t create = {};
pltype_t type = PL_Type (item);
if (type == QFDictionary) {
Fix a pile of leaks and uninit errors Still "some" more to go: a pile to do with transforms and temporary entities, and a nasty one with host_cbuf. There's also all the static block-alloc lists :/
2021-03-21 10:56:17 +00:00
if (!parse_object (ctx, memsuper, item, parse_imagecreate_dict,
&create, properties)) {
delete_memsuper (memsuper);
[vulkan] Start moving towards a deferred renderer After getting lights even vaguely working for alias models, I realized that it just wasn't going to be feasible to do nice lighting with forward rendering. This gets the bulk of the work done for deferred rendering, but still need to sort out the shaders before any real testing can be done.
2021-02-14 02:35:06 +00:00
return 0;
}
} else {
[util] Make developer flag names easier to manage They're now an enum, and the flag part of the name is all lowercase, but now the flag definitions and names list will never get out of sync.
2021-03-29 10:58:00 +00:00
Sys_MaskPrintf (SYS_vulkan_parse, "Neither array nor dictionary: %d\n",
[vulkan] Suppress all the debug output silence is golden
2021-03-23 04:04:22 +00:00
PL_Line (item));
Fix a pile of leaks and uninit errors Still "some" more to go: a pile to do with transforms and temporary entities, and a nasty one with host_cbuf. There's also all the static block-alloc lists :/
2021-03-21 10:56:17 +00:00
delete_memsuper (memsuper);
[vulkan] Start moving towards a deferred renderer After getting lights even vaguely working for alias models, I realized that it just wasn't going to be feasible to do nice lighting with forward rendering. This gets the bulk of the work done for deferred rendering, but still need to sort out the shaders before any real testing can be done.
2021-02-14 02:35:06 +00:00
return 0;
}
__auto_type set = QFV_AllocImages (create.count, malloc);
for (uint32_t i = 0; i < create.count; i++) {
[vulkan] Add a debug stack to the vulkan instance The stack is arbitrary strings that the validation layer debug callback prints in reverse order after each message. This makes it easy to work out what nodes in a pipeline/render pass plist are causing validation errors. Still have to narrow down the actual line, but the messages seem to help with that. Putting qfvPushDebug/qfvPopDebug around other calls to vulkan should help out a lot, tool. As a bonus, the stack is printed before debug_breakpoint is called, so it's immediately visible in gdb.
2021-11-30 03:24:45 +00:00
qfvPushDebug (ctx, va (ctx->va_ctx, "QFV_ParseImageSet: %d", PL_Line (item)));
[vulkan] Start moving towards a deferred renderer After getting lights even vaguely working for alias models, I realized that it just wasn't going to be feasible to do nice lighting with forward rendering. This gets the bulk of the work done for deferred rendering, but still need to sort out the shaders before any real testing can be done.
2021-02-14 02:35:06 +00:00
dfunc->vkCreateImage (device->dev, &create.info[i], 0, &set->a[i]);
const char *name = PL_KeyAtIndex (item, i);
[vulkan] Implement lighting and compose passes Lighting doesn't actually do lights yet, but it's producing pixels. Translucent seems to be working (2d draw uses it), and compose seems to be working.
2021-02-24 10:58:31 +00:00
QFV_duSetObjectName (device, VK_OBJECT_TYPE_IMAGE, set->a[i],
va (ctx->va_ctx, "image:%s", name));
[vulkan] Add a debug stack to the vulkan instance The stack is arbitrary strings that the validation layer debug callback prints in reverse order after each message. This makes it easy to work out what nodes in a pipeline/render pass plist are causing validation errors. Still have to narrow down the actual line, but the messages seem to help with that. Putting qfvPushDebug/qfvPopDebug around other calls to vulkan should help out a lot, tool. As a bonus, the stack is printed before debug_breakpoint is called, so it's immediately visible in gdb.
2021-11-30 03:24:45 +00:00
qfvPopDebug (ctx);
[vulkan] Clean up misuse of va for vulkan handles The built up "path" name of the handle resource was not always surviving the intervening call to cexpr_eval_string (in particular, when other handles were created in the process of creating a handle). Rather than simply increase the number of va buffers (where would it end?), just regenerate the path when adding the new handle. It's probably quick enough, and the code is not usually not on a critical path.
2021-04-22 10:47:42 +00:00
name = resource_path (ctx, "images", name);
[vulkan] Start moving towards a deferred renderer After getting lights even vaguely working for alias models, I realized that it just wasn't going to be feasible to do nice lighting with forward rendering. This gets the bulk of the work done for deferred rendering, but still need to sort out the shaders before any real testing can be done.
2021-02-14 02:35:06 +00:00
QFV_AddHandle (ctx->images, name, (uint64_t) set->a[i]);
}
Fix a pile of leaks and uninit errors Still "some" more to go: a pile to do with transforms and temporary entities, and a nasty one with host_cbuf. There's also all the static block-alloc lists :/
2021-03-21 10:56:17 +00:00
delete_memsuper (memsuper);
[vulkan] Start moving towards a deferred renderer After getting lights even vaguely working for alias models, I realized that it just wasn't going to be feasible to do nice lighting with forward rendering. This gets the bulk of the work done for deferred rendering, but still need to sort out the shaders before any real testing can be done.
2021-02-14 02:35:06 +00:00
return set;
}
qfv_imageviewset_t *
QFV_ParseImageViewSet (vulkan_ctx_t *ctx, plitem_t *item,
plitem_t *properties)
{
qfv_device_t *device = ctx->device;
qfv_devfuncs_t *dfunc = device->funcs;
Fix a pile of leaks and uninit errors Still "some" more to go: a pile to do with transforms and temporary entities, and a nasty one with host_cbuf. There's also all the static block-alloc lists :/
2021-03-21 10:56:17 +00:00
memsuper_t *memsuper = new_memsuper ();
[vulkan] Start moving towards a deferred renderer After getting lights even vaguely working for alias models, I realized that it just wasn't going to be feasible to do nice lighting with forward rendering. This gets the bulk of the work done for deferred rendering, but still need to sort out the shaders before any real testing can be done.
2021-02-14 02:35:06 +00:00
imageviewcreate_t create = {};
pltype_t type = PL_Type (item);
if (type == QFDictionary) {
Fix a pile of leaks and uninit errors Still "some" more to go: a pile to do with transforms and temporary entities, and a nasty one with host_cbuf. There's also all the static block-alloc lists :/
2021-03-21 10:56:17 +00:00
if (!parse_object (ctx, memsuper, item, parse_imageviewcreate_dict,
&create, properties)) {
delete_memsuper (memsuper);
[vulkan] Start moving towards a deferred renderer After getting lights even vaguely working for alias models, I realized that it just wasn't going to be feasible to do nice lighting with forward rendering. This gets the bulk of the work done for deferred rendering, but still need to sort out the shaders before any real testing can be done.
2021-02-14 02:35:06 +00:00
return 0;
}
} else {
Sys_Printf ("Neither array nor dictionary: %d\n", PL_Line (item));
Fix a pile of leaks and uninit errors Still "some" more to go: a pile to do with transforms and temporary entities, and a nasty one with host_cbuf. There's also all the static block-alloc lists :/
2021-03-21 10:56:17 +00:00
delete_memsuper (memsuper);
[vulkan] Start moving towards a deferred renderer After getting lights even vaguely working for alias models, I realized that it just wasn't going to be feasible to do nice lighting with forward rendering. This gets the bulk of the work done for deferred rendering, but still need to sort out the shaders before any real testing can be done.
2021-02-14 02:35:06 +00:00
return 0;
}
__auto_type set = QFV_AllocImageViews (create.count, malloc);
for (uint32_t i = 0; i < create.count; i++) {
[vulkan] Add a debug stack to the vulkan instance The stack is arbitrary strings that the validation layer debug callback prints in reverse order after each message. This makes it easy to work out what nodes in a pipeline/render pass plist are causing validation errors. Still have to narrow down the actual line, but the messages seem to help with that. Putting qfvPushDebug/qfvPopDebug around other calls to vulkan should help out a lot, tool. As a bonus, the stack is printed before debug_breakpoint is called, so it's immediately visible in gdb.
2021-11-30 03:24:45 +00:00
qfvPushDebug (ctx, va (ctx->va_ctx, "QFV_ParseImageViewSet: %d", PL_Line (item)));
[vulkan] Start moving towards a deferred renderer After getting lights even vaguely working for alias models, I realized that it just wasn't going to be feasible to do nice lighting with forward rendering. This gets the bulk of the work done for deferred rendering, but still need to sort out the shaders before any real testing can be done.
2021-02-14 02:35:06 +00:00
dfunc->vkCreateImageView (device->dev, &create.info[i], 0, &set->a[i]);
[vulkan] Add a debug stack to the vulkan instance The stack is arbitrary strings that the validation layer debug callback prints in reverse order after each message. This makes it easy to work out what nodes in a pipeline/render pass plist are causing validation errors. Still have to narrow down the actual line, but the messages seem to help with that. Putting qfvPushDebug/qfvPopDebug around other calls to vulkan should help out a lot, tool. As a bonus, the stack is printed before debug_breakpoint is called, so it's immediately visible in gdb.
2021-11-30 03:24:45 +00:00
qfvPopDebug (ctx);
[vulkan] Start moving towards a deferred renderer After getting lights even vaguely working for alias models, I realized that it just wasn't going to be feasible to do nice lighting with forward rendering. This gets the bulk of the work done for deferred rendering, but still need to sort out the shaders before any real testing can be done.
2021-02-14 02:35:06 +00:00
const char *name = PL_KeyAtIndex (item, i);
[vulkan] Clean up misuse of va for vulkan handles The built up "path" name of the handle resource was not always surviving the intervening call to cexpr_eval_string (in particular, when other handles were created in the process of creating a handle). Rather than simply increase the number of va buffers (where would it end?), just regenerate the path when adding the new handle. It's probably quick enough, and the code is not usually not on a critical path.
2021-04-22 10:47:42 +00:00
name = resource_path (ctx, "imageViews", name);
[vulkan] Start moving towards a deferred renderer After getting lights even vaguely working for alias models, I realized that it just wasn't going to be feasible to do nice lighting with forward rendering. This gets the bulk of the work done for deferred rendering, but still need to sort out the shaders before any real testing can be done.
2021-02-14 02:35:06 +00:00
QFV_AddHandle (ctx->imageViews, name, (uint64_t) set->a[i]);
}
Fix a pile of leaks and uninit errors Still "some" more to go: a pile to do with transforms and temporary entities, and a nasty one with host_cbuf. There's also all the static block-alloc lists :/
2021-03-21 10:56:17 +00:00
delete_memsuper (memsuper);
[vulkan] Start moving towards a deferred renderer After getting lights even vaguely working for alias models, I realized that it just wasn't going to be feasible to do nice lighting with forward rendering. This gets the bulk of the work done for deferred rendering, but still need to sort out the shaders before any real testing can be done.
2021-02-14 02:35:06 +00:00
return set;
}
VkFramebuffer
QFV_ParseFramebuffer (vulkan_ctx_t *ctx, plitem_t *plist, plitem_t *properties)
{
qfv_device_t *device = ctx->device;
qfv_devfuncs_t *dfunc = device->funcs;
Fix a pile of leaks and uninit errors Still "some" more to go: a pile to do with transforms and temporary entities, and a nasty one with host_cbuf. There's also all the static block-alloc lists :/
2021-03-21 10:56:17 +00:00
memsuper_t *memsuper = new_memsuper ();
[vulkan] Start moving towards a deferred renderer After getting lights even vaguely working for alias models, I realized that it just wasn't going to be feasible to do nice lighting with forward rendering. This gets the bulk of the work done for deferred rendering, but still need to sort out the shaders before any real testing can be done.
2021-02-14 02:35:06 +00:00
VkFramebufferCreateInfo cInfo = {};
Fix a pile of leaks and uninit errors Still "some" more to go: a pile to do with transforms and temporary entities, and a nasty one with host_cbuf. There's also all the static block-alloc lists :/
2021-03-21 10:56:17 +00:00
if (!parse_object (ctx, memsuper, plist, parse_VkFramebufferCreateInfo,
&cInfo, properties)) {
delete_memsuper (memsuper);
[vulkan] Start moving towards a deferred renderer After getting lights even vaguely working for alias models, I realized that it just wasn't going to be feasible to do nice lighting with forward rendering. This gets the bulk of the work done for deferred rendering, but still need to sort out the shaders before any real testing can be done.
2021-02-14 02:35:06 +00:00
return 0;
}
VkFramebuffer framebuffer;
[vulkan] Add a debug stack to the vulkan instance The stack is arbitrary strings that the validation layer debug callback prints in reverse order after each message. This makes it easy to work out what nodes in a pipeline/render pass plist are causing validation errors. Still have to narrow down the actual line, but the messages seem to help with that. Putting qfvPushDebug/qfvPopDebug around other calls to vulkan should help out a lot, tool. As a bonus, the stack is printed before debug_breakpoint is called, so it's immediately visible in gdb.
2021-11-30 03:24:45 +00:00
qfvPushDebug (ctx, va (ctx->va_ctx, "QFV_ParseFramebuffer: %d", PL_Line (plist)));
[vulkan] Start moving towards a deferred renderer After getting lights even vaguely working for alias models, I realized that it just wasn't going to be feasible to do nice lighting with forward rendering. This gets the bulk of the work done for deferred rendering, but still need to sort out the shaders before any real testing can be done.
2021-02-14 02:35:06 +00:00
dfunc->vkCreateFramebuffer (device->dev, &cInfo, 0, &framebuffer);
[vulkan] Add a debug stack to the vulkan instance The stack is arbitrary strings that the validation layer debug callback prints in reverse order after each message. This makes it easy to work out what nodes in a pipeline/render pass plist are causing validation errors. Still have to narrow down the actual line, but the messages seem to help with that. Putting qfvPushDebug/qfvPopDebug around other calls to vulkan should help out a lot, tool. As a bonus, the stack is printed before debug_breakpoint is called, so it's immediately visible in gdb.
2021-11-30 03:24:45 +00:00
qfvPopDebug (ctx);
[vulkan] Fix some 32-bit compatibility issues mostly dealing with vulkan's handles always being 64-bit, but pointers being either 32 or 64.
2021-04-01 23:48:11 +00:00
Sys_MaskPrintf (SYS_vulkan_parse, "framebuffer, renderPass: %#zx, %#zx\n",
(size_t) framebuffer, (size_t) cInfo.renderPass);
[vulkan] Start moving towards a deferred renderer After getting lights even vaguely working for alias models, I realized that it just wasn't going to be feasible to do nice lighting with forward rendering. This gets the bulk of the work done for deferred rendering, but still need to sort out the shaders before any real testing can be done.
2021-02-14 02:35:06 +00:00
Fix a pile of leaks and uninit errors Still "some" more to go: a pile to do with transforms and temporary entities, and a nasty one with host_cbuf. There's also all the static block-alloc lists :/
2021-03-21 10:56:17 +00:00
delete_memsuper (memsuper);
[vulkan] Start moving towards a deferred renderer After getting lights even vaguely working for alias models, I realized that it just wasn't going to be feasible to do nice lighting with forward rendering. This gets the bulk of the work done for deferred rendering, but still need to sort out the shaders before any real testing can be done.
2021-02-14 02:35:06 +00:00
return framebuffer;
}
[vulkan] Parse clear values And get the render pass working in general. Note that this is only the render pass and frame buffers: actual commands still have problems.
2021-02-23 05:37:48 +00:00
static int
parse_clearvalueset (const plfield_t *field, const plitem_t *item, void *data,
plitem_t *messages, void *context)
{
plelement_t element = {
QFDictionary,
sizeof (VkClearValue),
Fix a pile of leaks and uninit errors Still "some" more to go: a pile to do with transforms and temporary entities, and a nasty one with host_cbuf. There's also all the static block-alloc lists :/
2021-03-21 10:56:17 +00:00
vkparse_alloc,
[vulkan] Parse clear values And get the render pass working in general. Note that this is only the render pass and frame buffers: actual commands still have problems.
2021-02-23 05:37:48 +00:00
parse_VkClearValue,
0,
};
plfield_t f = { 0, 0, 0, 0, &element };
Fix a pile of leaks and uninit errors Still "some" more to go: a pile to do with transforms and temporary entities, and a nasty one with host_cbuf. There's also all the static block-alloc lists :/
2021-03-21 10:56:17 +00:00
if (!PL_ParseArray (&f, item, data, messages, context)) {
[vulkan] Parse clear values And get the render pass working in general. Note that this is only the render pass and frame buffers: actual commands still have problems.
2021-02-23 05:37:48 +00:00
return 0;
}
return 1;
}
[vulkan] Support multiple render passes Multiple render passes are needed for supporting shadow mapping, and this is a huge step towards breaking the Vulkan render free of Quake, and hopefully will lead the way for breaking the GL renderers free as well.
2021-12-02 12:58:29 +00:00
clearvalueset_t *
[vulkan] Parse clear values And get the render pass working in general. Note that this is only the render pass and frame buffers: actual commands still have problems.
2021-02-23 05:37:48 +00:00
QFV_ParseClearValues (vulkan_ctx_t *ctx, plitem_t *plist, plitem_t *properties)
{
[vulkan] Support multiple render passes Multiple render passes are needed for supporting shadow mapping, and this is a huge step towards breaking the Vulkan render free of Quake, and hopefully will lead the way for breaking the GL renderers free as well.
2021-12-02 12:58:29 +00:00
clearvalueset_t *cv = 0;
Fix a pile of leaks and uninit errors Still "some" more to go: a pile to do with transforms and temporary entities, and a nasty one with host_cbuf. There's also all the static block-alloc lists :/
2021-03-21 10:56:17 +00:00
memsuper_t *memsuper = new_memsuper ();
clearvalueset_t *clearValues = 0;
if (parse_object (ctx, memsuper, plist, parse_clearvalueset, &clearValues,
properties)) {
[vulkan] Support multiple render passes Multiple render passes are needed for supporting shadow mapping, and this is a huge step towards breaking the Vulkan render free of Quake, and hopefully will lead the way for breaking the GL renderers free as well.
2021-12-02 12:58:29 +00:00
cv = DARRAY_ALLOCFIXED (clearvalueset_t, clearValues->size, malloc);
memcpy (cv->a, clearValues->a, cv->size * sizeof (cv->a[0]));
[vulkan] Parse clear values And get the render pass working in general. Note that this is only the render pass and frame buffers: actual commands still have problems.
2021-02-23 05:37:48 +00:00
}
Fix a pile of leaks and uninit errors Still "some" more to go: a pile to do with transforms and temporary entities, and a nasty one with host_cbuf. There's also all the static block-alloc lists :/
2021-03-21 10:56:17 +00:00
delete_memsuper (memsuper);
[vulkan] Support multiple render passes Multiple render passes are needed for supporting shadow mapping, and this is a huge step towards breaking the Vulkan render free of Quake, and hopefully will lead the way for breaking the GL renderers free as well.
2021-12-02 12:58:29 +00:00
return cv;
[vulkan] Parse clear values And get the render pass working in general. Note that this is only the render pass and frame buffers: actual commands still have problems.
2021-02-23 05:37:48 +00:00
}
Reference in a new issue Copy permalink