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

1411 lines
38 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
#ifdef HAVE_MATH_H
# include <math.h>
#endif
#ifdef HAVE_STRING_H
# include <string.h>
#endif
#ifdef HAVE_STRINGS_H
# include <strings.h>
#endif
[vulkan] 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/cexpr.h"
#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"
#include "QF/dstring.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/input.h"
#include "QF/mathlib.h"
[util] Rename qfplist.[ch] The name is a hold-over from before the current quakeforge tree and the QF include directory.
2021-03-21 07:13:03 +00:00
#include "QF/plist.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/qargs.h"
#include "QF/quakefs.h"
#include "QF/sys.h"
#include "QF/va.h"
#include "QF/vid.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/simd/vec4f.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/qf_vid.h"
[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
#include "QF/Vulkan/descriptor.h"
[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/command.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] 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/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 "QF/Vulkan/swapchain.h"
#include "compat.h"
#include "d_iface.h"
#include "r_internal.h"
#include "vid_vulkan.h"
#include "util.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] 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;
[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.symtab = 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_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.symtab = 0;
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 };
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.symtab = 0;
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
}
[vulkan] Add support for custom parsers And provisionally parse shader stage defs.
2020-12-23 16:36:17 +00:00
static int
parse_data (const plfield_t *field, const plitem_t *item,
void *data, plitem_t *messages, void *context)
[vulkan] Add support for parsing binary data
2020-12-23 05:08:53 +00:00
{
__auto_type datad = (parse_data_t *) field->data;
__auto_type value = (void **) ((byte *)data + datad->value_offset);
__auto_type size = (size_t *) ((byte *)data + datad->size_offset);
const void *bindata = PL_BinaryData (item);
size_t binsize = PL_BinarySize (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_data: %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 %zd\n", datad->value_offset,
[vulkan] Suppress all the debug output silence is golden
2021-03-23 04:04:22 +00:00
datad->size_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, " %zd %p\n", binsize, bindata);
[vulkan] Add support for parsing binary data
2020-12-23 05:08:53 +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
*value = vkparse_alloc (context, binsize);
[vulkan] Add support for parsing binary data
2020-12-23 05:08:53 +00:00
memcpy (*value, bindata, binsize);
if ((void *) size > data) {
*size = binsize;
}
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);
}
[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.symtab = 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.symtab = 0;
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;
}
if (!(*handle = QFV_CreateShaderModule (device, name))) {
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.symtab = 0;
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.symtab = 0;
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.symtab = 0;
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;
}
static exprtype_t imageview_type = {
"VkImageView",
sizeof (VkImageView),
0, 0, 0
};
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.symtab = 0;
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;
if (value->type == &imageview_type) {
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] 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] 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
imageviewset_index (const exprval_t *a, size_t index, exprval_t *c,
exprctx_t *ctx)
{
__auto_type set = *(qfv_imageviewset_t **) a->value;
exprval_t *val = 0;
if (index >= set->size) {
cexpr_error (ctx, "invalid index: %zd", index);
} else {
val = cexpr_value (&imageview_type, ctx);
*(VkImageView *) val->value = set->a[index];
}
*(exprval_t **) c->value = val;
}
static void
imageviewset_int (const exprval_t *a, const exprval_t *b, exprval_t *c,
exprctx_t *ctx)
{
size_t index = *(int *) b->value;
imageviewset_index (a, index, c, ctx);
}
static void
imageviewset_uint (const exprval_t *a, const exprval_t *b, exprval_t *c,
exprctx_t *ctx)
{
size_t index = *(unsigned *) b->value;
imageviewset_index (a, index, c, ctx);
}
static void
imageviewset_size_t (const exprval_t *a, const exprval_t *b, exprval_t *c,
exprctx_t *ctx)
{
size_t index = *(size_t *) b->value;
imageviewset_index (a, index, c, ctx);
}
binop_t imageviewset_binops[] = {
{ '.', &cexpr_field, &cexpr_exprval, cexpr_struct_pointer_getfield },
{ '[', &cexpr_int, &imageview_type, imageviewset_int },
{ '[', &cexpr_uint, &imageview_type, imageviewset_uint },
{ '[', &cexpr_size_t, &imageview_type, imageviewset_size_t },
{}
};
static exprsym_t imageviewset_symbols[] = {
{"size", &cexpr_size_t, (void *)field_offset (qfv_imageviewset_t, size)},
[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] 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 exprtab_t imageviewset_symtab = {
imageviewset_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] 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
exprtype_t imageviewset_type = {
"imageviewset",
sizeof (qfv_imageviewset_t *),
imageviewset_binops,
[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
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
&imageviewset_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
};
static exprsym_t qfv_swapchain_t_symbols[] = {
{"format", &VkFormat_type, (void *)field_offset (qfv_swapchain_t, format)},
[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
{"extent", &VkExtent2D_type, (void *)field_offset (qfv_swapchain_t, extent)},
{"views", &imageviewset_type, (void *)field_offset (qfv_swapchain_t, imageViews)},
[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
{ }
};
static exprtab_t qfv_swapchain_t_symtab = {
qfv_swapchain_t_symbols,
};
exprtype_t qfv_swapchain_t_type = {
"qfv_swapchain_t",
sizeof (qfv_swapchain_t),
cexpr_struct_binops,
0,
&qfv_swapchain_t_symtab,
};
[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 = {
"frameset",
sizeof (vulkan_frameset_t *),
[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
cexpr_struct_binops,
0,
[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
&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] 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 qfv_renderpass_s {
qfv_attachmentdescription_t *attachments;
qfv_subpassparametersset_t *subpasses;
qfv_subpassdependency_t *dependencies;
} qfv_renderpass_t;
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[] = {
{ "attachments", field_offset (qfv_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] 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
{ "subpasses", field_offset (qfv_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] 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
{ "dependencies", field_offset (qfv_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)
{
return Hash_NewTable (23, handleref_getkey, free_func,
ctx, &ctx->hashlinks);
}
[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;
}
void
QFV_InitParse (vulkan_ctx_t *ctx)
{
exprctx_t context = {};
enum_symtab = Hash_NewTable (61, enum_symtab_getkey, 0, 0,
&ctx->hashlinks);
context.hashlinks = &ctx->hashlinks;
vkgen_init_symtabs (&context);
[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
cexpr_init_symtab (&qfv_swapchain_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] 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
cexpr_init_symtab (&imageviewset_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] 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_t exprctx = {};
[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[] = {
{"swapchain", &qfv_swapchain_t_type, ctx->swapchain},
[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] 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
{"swapImageIndex", &cexpr_uint, &ctx->swapImageIndex},
{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;
[util] Make exprctx hashlinks double pointer The way I wound up using the field meant that exprctx should not "own" the hashlinks chain, but rather just point to it. This fixes the nasty access errors I had.
2021-01-05 10:55:17 +00:00
exprctx.hashlinks = &ctx->hashlinks;
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;
qfv_renderpass_t renderpass_data = {};
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] 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);
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] 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_ParsePipeline (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] 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].renderPass = ctx->renderpass;
[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);
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;
dfunc->vkCreateDescriptorPool (device->dev, &cInfo, 0, &pool);
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;
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] 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;
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] 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;
dfunc->vkCreateSampler (device->dev, &cInfo, 0, &sampler);
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;
dfunc->vkCreateImage (device->dev, &cInfo, 0, &image);
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;
dfunc->vkCreateImageView (device->dev, &cInfo, 0, &imageView);
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++) {
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] 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++) {
dfunc->vkCreateImageView (device->dev, &create.info[i], 0, &set->a[i]);
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;
dfunc->vkCreateFramebuffer (device->dev, &cInfo, 0, &framebuffer);
[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;
}
int
QFV_ParseClearValues (vulkan_ctx_t *ctx, plitem_t *plist, plitem_t *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
int ret = 0;
memsuper_t *memsuper = new_memsuper ();
clearvalueset_t *clearValues = 0;
ctx->clearValues = 0;
if (parse_object (ctx, memsuper, plist, parse_clearvalueset, &clearValues,
properties)) {
ret = 1;
ctx->clearValues = DARRAY_ALLOCFIXED (clearvalueset_t,
clearValues->size, malloc);
memcpy (ctx->clearValues->a, clearValues->a,
clearValues->size * sizeof (clearValues->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);
return ret;
[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