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

2456 lines
66 KiB
C
Raw Normal View History

[vulkan] Start work on scripted pipeline Nothing is actually done yet other than parsing the built-in property list to property list items (the actual parser is just a skeleton), but everything compiles
2020-07-16 06:42:49 +00:00
/*
vkparse.c
Parser for scripted vulkan structs
Copyright (C) 2020 Bill Currie <bill@taniwha.org>
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to:
Free Software Foundation, Inc.
59 Temple Place - Suite 330
Boston, MA 02111-1307, USA
*/
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
[vulkan] Clean up a lot of unnecessary includes Too much copying of base files.
2022-03-30 06:54:07 +00:00
#include <string.h>
[vulkan] Start work on scripted pipeline Nothing is actually done yet other than parsing the built-in property list to property list items (the actual parser is just a skeleton), but everything compiles
2020-07-16 06:42:49 +00:00
[vulkan] Hook up the expression parser The pipeline parser still isn't hooked up yet as something isn't quite right, but it seems all the parsing works.
2020-12-21 09:38:31 +00:00
#include "QF/cmem.h"
[vulkan] Start work on scripted pipeline Nothing is actually done yet other than parsing the built-in property list to property list items (the actual parser is just a skeleton), but everything compiles
2020-07-16 06:42:49 +00:00
#include "QF/cvar.h"
[vulkan] Make script support objects more private This will help keep changes to the scripting system localized once things are further cleaned up.
2022-11-24 14:44:07 +00:00
#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/mathlib.h"
#include "QF/va.h"
[vulkan] Clean up a lot of unnecessary includes Too much copying of base files.
2022-03-30 06:54:07 +00:00
[vulkan] Name most resources This makes debugging with renderdoc and validation messages much easier (no more "what buffer is that?").
2021-01-31 10:58:55 +00:00
#include "QF/Vulkan/debug.h"
[vulkan] Start work on scripted pipeline Nothing is actually done yet other than parsing the built-in property list to property list items (the actual parser is just a skeleton), but everything compiles
2020-07-16 06:42:49 +00:00
#include "QF/Vulkan/device.h"
#include "QF/Vulkan/instance.h"
#include "QF/Vulkan/image.h"
[vulkan] Implement pipeline creation The prototypes for handle parsers needed to be changes because it turned out "single" was inappropriate for handles as "single" allocates memory for the parsed object, but handles must be written directly.
2021-01-05 14:42:30 +00:00
#include "QF/Vulkan/pipeline.h"
[vulkan] Generate parse data for new render pass structs There's still a lot of work to do, but the basics are in. The spec will be parsed into info structs that can then be further processed to generate all the actual structs, generally making things a little less timing dependent (eg, image view info refers to its image by name). The new render pass and subpass structs have their names mangled for now until I can switch over to the new system.
2023-02-09 05:52:43 +00:00
#include "QF/Vulkan/render.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
[vulkan] Rename the renderpass files I plan on moving the current hard-coded render pass creation from vulkan_vid_common and this maintains the (possibly silly) naming convention).
2022-05-30 03:10:00 +00:00
#include "QF/Vulkan/qf_renderpass.h"
[vulkan] Start work on scripted pipeline Nothing is actually done yet other than parsing the built-in property list to property list items (the actual parser is just a skeleton), but everything compiles
2020-07-16 06:42:49 +00:00
#include "vid_vulkan.h"
#include "vkparse.h"
[vulkan] Remove vkparse.hinc from vkparse.h Kind of silly having the vkparse_internal define when it was just bypassed anyway.
2022-05-30 03:22:34 +00:00
#include "libs/video/renderer/vulkan/vkparse.hinc"
[vulkan] Start work on scripted pipeline Nothing is actually done yet other than parsing the built-in property list to property list items (the actual parser is just a skeleton), but everything compiles
2020-07-16 06:42:49 +00:00
[vulkan] Break render pass parsing away from swapchain This allows a single render pass description to be used for both on-screen and off-screen targets. While Vulkan does allow a VkRenderPass to be used with any compatible frame buffer, and vkparse caches a VkRenderPass created from the same description, this allows the same description to be used for a compatible off-screen target without any dependence on the swapchain. However, there is a problem in the caching when it comes to targeting outputs with different formats.
2022-04-02 02:42:36 +00:00
typedef struct parseres_s {
const char *name;
plfield_t *field;
size_t offset;
} parseres_t;
[vulkan] Support Vulkan's pNext in vkparse/vkgen The real reason for the delay in implementing support for pNext is I didn't know how to approach it at the time, but with the experience I've gained using and modifying vkparse, the solution turned out to be fairly simple. This allows for the use of various extensions (eg, multiview, which was used for testing, though none of the hookup is in this commit). No checking is done on the struct type being valid other than it must be of a chainable type (ie, have its own pNext).
2022-05-29 12:53:38 +00:00
typedef struct parseref_s {
const char *name;
plparser_t parse;
size_t size;
} parserref_t;
[vulkan] Break render pass parsing away from swapchain This allows a single render pass description to be used for both on-screen and off-screen targets. While Vulkan does allow a VkRenderPass to be used with any compatible frame buffer, and vkparse caches a VkRenderPass created from the same description, this allows the same description to be used for a compatible off-screen target without any dependence on the swapchain. However, there is a problem in the caching when it comes to targeting outputs with different formats.
2022-04-02 02:42:36 +00:00
typedef struct handleref_s {
char *name;
uint64_t handle;
} handleref_t;
[vulkan] Hook up the expression parser The pipeline parser still isn't hooked up yet as something isn't quite right, but it seems all the parsing works.
2020-12-21 09:38:31 +00:00
static void flag_or (const exprval_t *val1, const exprval_t *val2,
exprval_t *result, exprctx_t *ctx)
{
*(int *) (result->value) = *(int *) (val1->value) | *(int *) (val2->value);
}
static void flag_and (const exprval_t *val1, const exprval_t *val2,
exprval_t *result, exprctx_t *ctx)
{
*(int *) (result->value) = *(int *) (val1->value) & *(int *) (val2->value);
}
static void flag_cast_int (const exprval_t *val1, const exprval_t *val2,
exprval_t *result, exprctx_t *ctx)
{
// FIXME should check value is valid
*(int *) (result->value) = *(int *) (val2->value);
}
static void flag_not (const exprval_t *val, exprval_t *result, exprctx_t *ctx)
{
*(int *) (result->value) = ~(*(int *) (val->value));
}
binop_t flag_binops[] = {
{ '|', 0, 0, flag_or },
{ '&', 0, 0, flag_and },
{ '=', &cexpr_int, 0, flag_cast_int },
[util] Auto-cast plist string items The casting uses a recursive call to the expression parser, so the expressions are type-checked automatically.
2021-02-04 13:37:20 +00:00
{ '=', &cexpr_plitem, 0, cexpr_cast_plitem },
{}
};
binop_t enum_binops[] = {
{ '=', &cexpr_plitem, 0, cexpr_cast_plitem },
[vulkan] Hook up the expression parser The pipeline parser still isn't hooked up yet as something isn't quite right, but it seems all the parsing works.
2020-12-21 09:38:31 +00:00
{}
};
unop_t flag_unops[] = {
{ '~', 0, flag_not },
{}
};
[vulkan] Start work on scripted pipeline Nothing is actually done yet other than parsing the built-in property list to property list items (the actual parser is just a skeleton), but everything compiles
2020-07-16 06:42:49 +00:00
typedef struct parse_single_s {
[vulkan] Implement most of the parser This gets renderpass parsing almost working (not hooked up, though). The missing bits are support for expressions for flags (namely support for the | operator) and references (eg $swapchain.format). However, this shows that the basic concept for the parser is working.
2020-07-16 15:29:53 +00:00
pltype_t type;
size_t stride;
[vulkan] Start work on scripted pipeline Nothing is actually done yet other than parsing the built-in property list to property list items (the actual parser is just a skeleton), but everything compiles
2020-07-16 06:42:49 +00:00
plparser_t parser;
[vkgen] Add support for array element data While I wound up not needing it in the end, it's now possible to specify extra data for array element parsing.
2023-02-10 10:33:10 +00:00
void *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
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;
[vkgen] Add support for array element data While I wound up not needing it in the end, it's now possible to specify extra data for array element parsing.
2023-02-10 10:33:10 +00:00
void *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
size_t value_offset;
[vulkan] Implement most of the parser This gets renderpass parsing almost working (not hooked up, though). The missing bits are support for expressions for flags (namely support for the | operator) and references (eg $swapchain.format). However, this shows that the basic concept for the parser is working.
2020-07-16 15:29:53 +00:00
size_t size_offset;
[vulkan] Start work on scripted pipeline Nothing is actually done yet other than parsing the built-in property list to property list items (the actual parser is just a skeleton), but everything compiles
2020-07-16 06:42:49 +00:00
} parse_array_t;
[vkgen] Add support for fixed arrays I want to support reading VkPhysicalDeviceLimits but it has some arrays. While I don't need to parse them (VkPhysicalDeviceLimits should be treated as read-only), I do need to be able to access them in property list expressions, and vkgen generates the cexpr type descriptors too. However, I will probably want to parse arrays some time in the future.
2021-12-04 01:08:27 +00:00
typedef struct parse_fixed_array_s {
pltype_t type;
size_t stride;
plparser_t parser;
[vkgen] Add support for array element data While I wound up not needing it in the end, it's now possible to specify extra data for array element parsing.
2023-02-10 10:33:10 +00:00
void *data;
[vkgen] Add support for fixed arrays I want to support reading VkPhysicalDeviceLimits but it has some arrays. While I don't need to parse them (VkPhysicalDeviceLimits should be treated as read-only), I do need to be able to access them in property list expressions, and vkgen generates the cexpr type descriptors too. However, I will probably want to parse arrays some time in the future.
2021-12-04 01:08:27 +00:00
size_t size;
} parse_fixed_array_t;
[vulkan] Add support for parsing binary data
2020-12-23 05:08:53 +00:00
typedef struct parse_data_s {
size_t value_offset;
size_t size_offset;
} parse_data_t;
[vulkan] Refactor vkgen struct generation The addition of data an then string support made keeping track of things in struct's writeTable a nightmare.
2020-12-23 13:13:50 +00:00
typedef struct parse_string_s {
size_t value_offset;
} parse_string_t;
[vulkan] Add support for custom parsers And provisionally parse shader stage defs.
2020-12-23 16:36:17 +00:00
typedef struct parse_custom_s {
int (*parse) (const plitem_t *item, void **data,
plitem_t *messages, parsectx_t *context);
size_t *offsets;
size_t num_offsets;
} parse_custom_t;
[vkgen] Improve .type parse spec handling .dictionary can ask for standard parsing via a .parse key (value is ignored currently). Fields can use $auto to use standard parsing for that field. If either is used, the plist field descriptors are written.
2023-02-18 08:00:52 +00:00
static plfield_t *__attribute__((used))
find_field (plfield_t *fields, const char *field_name,
const plitem_t *item, plitem_t *messages)
{
for (plfield_t *f = fields; f->name; f++) {
if (strcmp (f->name, field_name) == 0) {
return f;
}
}
PL_Message (messages, item, "error: unknown field %s", field_name);
return 0;
}
[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;
[vulkan] Be more consistent with parse context naming
2022-11-23 02:34:20 +00:00
parsectx_t *pctx = context;
[vulkan] Support parsing numeric types
2020-12-24 00:58:27 +00:00
__auto_type etype = (exprtype_t *) field->data;
[vulkan] Be more consistent with parse context naming
2022-11-23 02:34:20 +00:00
exprctx_t ectx = *pctx->ectx;
[vulkan] Support parsing numeric types
2020-12-24 00:58:27 +00:00
exprval_t result = { etype, data };
ectx.result = &result;
[vulkan] Set source item for cexpr errors It's always nice getting at least line numbers from an error message (even if I still have to hunt for the right source "file").
2022-05-30 07:12:42 +00:00
ectx.item = item;
[vulkan] Support parsing numeric types
2020-12-24 00:58:27 +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_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] Support Vulkan's pNext in vkparse/vkgen The real reason for the delay in implementing support for pNext is I didn't know how to approach it at the time, but with the experience I've gained using and modifying vkparse, the solution turned out to be fairly simple. This allows for the use of various extensions (eg, multiview, which was used for testing, though none of the hookup is in this commit). No checking is done on the struct type being valid other than it must be of a chainable type (ie, have its own pNext).
2022-05-29 12:53:38 +00:00
static int
parse_int32_t (const plfield_t *field, const plitem_t *item,
void *data, plitem_t *messages, void *context)
{
int ret = 1;
// use size_t (and cexpr_size_t) for val so references to array sizes
// can be used
size_t val = 0;
[vulkan] Be more consistent with parse context naming
2022-11-23 02:34:20 +00:00
parsectx_t *pctx = context;
[vulkan] Support Vulkan's pNext in vkparse/vkgen The real reason for the delay in implementing support for pNext is I didn't know how to approach it at the time, but with the experience I've gained using and modifying vkparse, the solution turned out to be fairly simple. This allows for the use of various extensions (eg, multiview, which was used for testing, though none of the hookup is in this commit). No checking is done on the struct type being valid other than it must be of a chainable type (ie, have its own pNext).
2022-05-29 12:53:38 +00:00
exprval_t result = { &cexpr_size_t, &val };
[vulkan] Be more consistent with parse context naming
2022-11-23 02:34:20 +00:00
exprctx_t ectx = *pctx->ectx;
[vulkan] Support Vulkan's pNext in vkparse/vkgen The real reason for the delay in implementing support for pNext is I didn't know how to approach it at the time, but with the experience I've gained using and modifying vkparse, the solution turned out to be fairly simple. This allows for the use of various extensions (eg, multiview, which was used for testing, though none of the hookup is in this commit). No checking is done on the struct type being valid other than it must be of a chainable type (ie, have its own pNext).
2022-05-29 12:53:38 +00:00
ectx.result = &result;
[vulkan] Set source item for cexpr errors It's always nice getting at least line numbers from an error message (even if I still have to hunt for the right source "file").
2022-05-30 07:12:42 +00:00
ectx.item = item;
[vulkan] Support Vulkan's pNext in vkparse/vkgen The real reason for the delay in implementing support for pNext is I didn't know how to approach it at the time, but with the experience I've gained using and modifying vkparse, the solution turned out to be fairly simple. This allows for the use of various extensions (eg, multiview, which was used for testing, though none of the hookup is in this commit). No checking is done on the struct type being valid other than it must be of a chainable type (ie, have its own pNext).
2022-05-29 12:53:38 +00:00
const char *valstr = PL_String (item);
//Sys_MaskPrintf (SYS_vulkan_parse,
// "parse_int32_t: %s %zd %d %p %p %s\n",
// field->name, field->offset, field->type, field->parser,
// field->data, valstr);
ret = !cexpr_eval_string (valstr, &ectx);
if (!ret) {
PL_Message (messages, item, "error parsing %s: %s",
field->name, valstr);
}
*(int32_t *) data = val;
//Sys_MaskPrintf (SYS_vulkan_parse, " %d\n", *(int32_t *)data);
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;
[vulkan] Be more consistent with parse context naming
2022-11-23 02:34:20 +00:00
parsectx_t *pctx = context;
[vulkan] Use a size_t temp to parse uint32 values Needed for swapbuffer frame count
2021-01-10 06:29:47 +00:00
exprval_t result = { &cexpr_size_t, &val };
[vulkan] Be more consistent with parse context naming
2022-11-23 02:34:20 +00:00
exprctx_t ectx = *pctx->ectx;
[vulkan] Support parsing numeric types
2020-12-24 00:58:27 +00:00
ectx.result = &result;
[vulkan] Set source item for cexpr errors It's always nice getting at least line numbers from an error message (even if I still have to hunt for the right source "file").
2022-05-30 07:12:42 +00:00
ectx.item = 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
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] Be more consistent with parse context naming
2022-11-23 02:34:20 +00:00
parsectx_t *pctx = context;
exprctx_t ectx = *pctx->ectx;
[vulkan] Hook up the expression parser The pipeline parser still isn't hooked up yet as something isn't quite right, but it seems all the parsing works.
2020-12-21 09:38:31 +00:00
exprval_t result = { enm->type, data };
[vulkan] Be more consistent with parse context naming
2022-11-23 02:34:20 +00:00
ectx.parent = pctx->ectx;
[vulkan] Hook up the expression parser The pipeline parser still isn't hooked up yet as something isn't quite right, but it seems all the parsing works.
2020-12-21 09:38:31 +00:00
ectx.symtab = enm->symtab;
ectx.result = &result;
[vulkan] Implement most of the parser This gets renderpass parsing almost working (not hooked up, though). The missing bits are support for expressions for flags (namely support for the | operator) and references (eg $swapchain.format). However, this shows that the basic concept for the parser is working.
2020-07-16 15:29:53 +00:00
const char *valstr = PL_String (item);
[util] Make developer flag names easier to manage They're now an enum, and the flag part of the name is all lowercase, but now the flag definitions and names list will never get out of sync.
2021-03-29 10:58:00 +00:00
//Sys_MaskPrintf (SYS_vulkan_parse, "parse_enum: %s %zd %d %p %p %s\n",
[vulkan] Suppress all the debug output silence is golden
2021-03-23 04:04:22 +00:00
// field->name, field->offset, field->type, field->parser,
// field->data, valstr);
[vulkan] Hook up the expression parser The pipeline parser still isn't hooked up yet as something isn't quite right, but it seems all the parsing works.
2020-12-21 09:38:31 +00:00
ret = !cexpr_parse_enum (enm, valstr, &ectx, data);
[vulkan] Generate code for resource nodes This makes it easy to add resource nodes defining contextually named resources. It is already used for shaders, set layouts, and pipeline layouts.
2021-01-05 05:15:35 +00:00
if (!ret) {
PL_Message (messages, item, "error parsing enum: %s", valstr);
}
[util] Make developer flag names easier to manage They're now an enum, and the flag part of the name is all lowercase, but now the flag definitions and names list will never get out of sync.
2021-03-29 10:58:00 +00:00
//Sys_MaskPrintf (SYS_vulkan_parse, " %d\n", *(int *)data);
[vulkan] Implement most of the parser This gets renderpass parsing almost working (not hooked up, though). The missing bits are support for expressions for flags (namely support for the | operator) and references (eg $swapchain.format). However, this shows that the basic concept for the parser is working.
2020-07-16 15:29:53 +00:00
return ret;
[vulkan] Start work on scripted pipeline Nothing is actually done yet other than parsing the built-in property list to property list items (the actual parser is just a skeleton), but everything compiles
2020-07-16 06:42:49 +00:00
}
[vulkan] Allow all struct objects to be referenced
2021-02-14 02:20:54 +00:00
static const plitem_t *
parse_reference (const plitem_t *item, const char *type, plitem_t *messages,
parsectx_t *pctx)
{
exprctx_t ectx = *pctx->ectx;
plitem_t *refItem = 0;
exprval_t result = { &cexpr_plitem, &refItem };
ectx.result = &result;
[vulkan] Set source item for cexpr errors It's always nice getting at least line numbers from an error message (even if I still have to hunt for the right source "file").
2022-05-30 07:12:42 +00:00
ectx.item = item;
[vulkan] Allow all struct objects to be referenced
2021-02-14 02:20:54 +00:00
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] Support parsing qfv_output_t This will be needed by the revamped render pass code.
2022-11-26 13:22:22 +00:00
static int
parse_ignore (const plfield_t *field, const plitem_t *item,
void *data, plitem_t *messages, void *context)
{
return 1;
}
[vkgen] Add support for labeled array elements This treats dictionary items as arrays ordered by key creation (ie, the order of the key/value pairs in the dictionary is preserved). The label is written to the specified field when parsing the struct. Both actual arrays and single element "arrays" are supported.
2023-02-10 10:36:53 +00:00
static int __attribute__((used))
parse_labeledsingle (const plfield_t *field, const plitem_t *item,
void *data, plitem_t *messages, void *context)
{
__auto_type single = (parse_single_t *) field->data;
void *flddata = (byte *)data + single->value_offset;
//Sys_MaskPrintf (SYS_vulkan_parse,"parse_labeledsingle: %s %zd %d %p %p\n",
// field->name, field->offset,
// field->type, field->parser, field->data);
[vulkan] Get render info parsing mostly working Just frame buffer and pipeline info to clean up before worrying about tasks.
2023-02-10 16:15:19 +00:00
const char *key = PL_KeyAtIndex (item, 0);
if (!key) {
PL_Message (messages, item, "missing item");
return 0;
}
item = PL_ObjectForKey (item, key);
[vkgen] Add support for labeled array elements This treats dictionary items as arrays ordered by key creation (ie, the order of the key/value pairs in the dictionary is preserved). The label is written to the specified field when parsing the struct. Both actual arrays and single element "arrays" are supported.
2023-02-10 10:36:53 +00:00
if (!PL_CheckType (single->type, PL_Type (item))) {
PL_TypeMismatch (messages, item, field->name, single->type,
PL_Type (item));
return 0;
}
[vulkan] Get render info parsing mostly working Just frame buffer and pipeline info to clean up before worrying about tasks.
2023-02-10 16:15:19 +00:00
plfield_t f = { field->name, 0, single->type, single->parser, 0 };
[vkgen] Add support for labeled array elements This treats dictionary items as arrays ordered by key creation (ie, the order of the key/value pairs in the dictionary is preserved). The label is written to the specified field when parsing the struct. Both actual arrays and single element "arrays" are supported.
2023-02-10 10:36:53 +00:00
void *value = vkparse_alloc (context, single->stride);
memset (value, 0, single->stride);
if (!single->parser (&f, item, value, messages, context)) {
return 0;
}
*(void **) flddata = value;
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_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;
}
[vkgen] Improve .type parse spec handling .dictionary can ask for standard parsing via a .parse key (value is ignored currently). Fields can use $auto to use standard parsing for that field. If either is used, the plist field descriptors are written.
2023-02-18 08:00:52 +00:00
plfield_t f = { field->name, 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
}
[vkgen] Add support for labeled array elements This treats dictionary items as arrays ordered by key creation (ie, the order of the key/value pairs in the dictionary is preserved). The label is written to the specified field when parsing the struct. Both actual arrays and single element "arrays" are supported.
2023-02-10 10:36:53 +00:00
static int __attribute__((used))
parse_labeledarray (const plfield_t *field, const plitem_t *item,
void *data, plitem_t *messages, void *context)
{
__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,
vkparse_alloc,
array->parser,
array->data,
};
plfield_t f = { 0, 0, 0, 0, &element };
typedef struct arr_s DARRAY_TYPE(byte) arr_t;
arr_t *arr;
//Sys_MaskPrintf (SYS_vulkan_parse, "parse_array: %s %zd %d %p %p %p\n",
// field->name, field->offset, field->type, field->parser,
// field->data, data);
//Sys_MaskPrintf (SYS_vulkan_parse, " %d %zd %p %zd %zd\n", array->type,
// array->stride, array->parser, array->value_offset,
// array->size_offset);
if (!PL_ParseLabeledArray (&f, item, &arr, messages, context)) {
return 0;
}
*value = vkparse_alloc (context, array->stride * arr->size);
memcpy (*value, arr->a, array->stride * arr->size);
if ((void *) size >= data) {
*size = arr->size;
}
return 1;
}
[vulkan] Add support for custom parsers And provisionally parse shader stage defs.
2020-12-23 16:36:17 +00:00
static int
parse_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,
[vkgen] Add support for array element data While I wound up not needing it in the end, it's now possible to specify extra data for array element parsing.
2023-02-10 10:33:10 +00:00
array->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
};
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 initial render info parser It doesn't work yet, but I've some otherwise breaking changes I want in (getting this in now prevents the breakage).
2023-02-09 12:17:04 +00:00
static int __attribute__((used))
[vkgen] Add support for fixed arrays I want to support reading VkPhysicalDeviceLimits but it has some arrays. While I don't need to parse them (VkPhysicalDeviceLimits should be treated as read-only), I do need to be able to access them in property list expressions, and vkgen generates the cexpr type descriptors too. However, I will probably want to parse arrays some time in the future.
2021-12-04 01:08:27 +00:00
parse_fixed_array (const plfield_t *field, const plitem_t *item,
void *data, plitem_t *messages, void *context)
{
__auto_type array = (parse_fixed_array_t *) field->data;
plelement_t element = {
array->type,
array->stride,
vkparse_alloc,
array->parser,
[vkgen] Add support for array element data While I wound up not needing it in the end, it's now possible to specify extra data for array element parsing.
2023-02-10 10:33:10 +00:00
array->data,
[vkgen] Add support for fixed arrays I want to support reading VkPhysicalDeviceLimits but it has some arrays. While I don't need to parse them (VkPhysicalDeviceLimits should be treated as read-only), I do need to be able to access them in property list expressions, and vkgen generates the cexpr type descriptors too. However, I will probably want to parse arrays some time in the future.
2021-12-04 01:08:27 +00:00
};
plfield_t f = { 0, 0, 0, 0, &element };
typedef struct arr_s DARRAY_TYPE(byte) arr_t;
arr_t *arr;
if (!PL_ParseArray (&f, item, &arr, messages, context)) {
return 0;
}
memset (data, 0, array->stride * array->size);
size_t size = min (array->size, arr->size);
memcpy (data, arr->a, array->stride * size);
return 1;
}
[vkgen] Add support for labeled array elements This treats dictionary items as arrays ordered by key creation (ie, the order of the key/value pairs in the dictionary is preserved). The label is written to the specified field when parsing the struct. Both actual arrays and single element "arrays" are supported.
2023-02-10 10:36:53 +00:00
static char *
vkstrdup (parsectx_t *context, const char *str)
{
size_t len = strlen (str) + 1;
char *dup = vkparse_alloc (context, len);
memcpy (dup, str, len);
return dup;
}
[vulkan] Try to create render passes and pipelines The render passes seem to be created successfully, but pipelines fail due to not having layout set, resulting in a segfault (bug in validation layers?).
2023-02-20 15:44:26 +00:00
static __attribute__((used)) parse_string_t parse_string_array = { 0 };
[vulkan] Get render info parsing mostly working Just frame buffer and pipeline info to clean up before worrying about tasks.
2023-02-10 16:15:19 +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_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
[vkgen] Add support for labeled array elements This treats dictionary items as arrays ordered by key creation (ie, the order of the key/value pairs in the dictionary is preserved). The label is written to the specified field when parsing the struct. Both actual arrays and single element "arrays" are supported.
2023-02-10 10:36:53 +00:00
*value = vkstrdup (context, 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
return 1;
}
[vulkan] Add support for custom parsers And provisionally parse shader stage defs.
2020-12-23 16:36:17 +00:00
static int
parse_custom (const plfield_t *field, const plitem_t *item,
void *data, plitem_t *messages, void *context)
{
__auto_type custom = (parse_custom_t *) field->data;
void **offsets = alloca (custom->num_offsets * sizeof (void *));
for (size_t i = 0; i < custom->num_offsets; i++) {
offsets[i] = data + custom->offsets[i];
}
return custom->parse (item, offsets, messages, context);
}
[vkparse] Add support for inheriting objects It simply parses the referenced plist dictionary (via @inherit = plist.path;) into the current data block, then allows the data to be overwritten by the current plist dictionary. This may be a bit iffy for any allocated resources, so some care must be taken, but it seems to work nicely.
2022-04-03 02:11:28 +00:00
static int
parse_inherit (const plfield_t *field, const plitem_t *item,
void *data, plitem_t *messages, void *context)
{
[vulkan] Be more consistent with parse context naming
2022-11-23 02:34:20 +00:00
parsectx_t *pctx = context;
exprctx_t ectx = *pctx->ectx;
[vkparse] Add support for inheriting objects It simply parses the referenced plist dictionary (via @inherit = plist.path;) into the current data block, then allows the data to be overwritten by the current plist dictionary. This may be a bit iffy for any allocated resources, so some care must be taken, but it seems to work nicely.
2022-04-03 02:11:28 +00:00
plitem_t *inheritItem = 0;
exprval_t result = { &cexpr_plitem, &inheritItem };
ectx.result = &result;
[vulkan] Set source item for cexpr errors It's always nice getting at least line numbers from an error message (even if I still have to hunt for the right source "file").
2022-05-30 07:12:42 +00:00
ectx.item = item;
[vkparse] Add support for inheriting objects It simply parses the referenced plist dictionary (via @inherit = plist.path;) into the current data block, then allows the data to be overwritten by the current plist dictionary. This may be a bit iffy for any allocated resources, so some care must be taken, but it seems to work nicely.
2022-04-03 02:11:28 +00:00
const char *inheritstr = PL_String (item);
[vulkan] Implement task function parsing This just sets up the memory block and cexpr descriptors for the parameters, parameter parsing is separate (and next). The parameters are aligned to their size.
2023-02-12 16:43:17 +00:00
//Sys_MaskPrintf (SYS_vulkan_parse, "parse_inherit: %s\n", inheritstr);
[vkparse] Add support for inheriting objects It simply parses the referenced plist dictionary (via @inherit = plist.path;) into the current data block, then allows the data to be overwritten by the current plist dictionary. This may be a bit iffy for any allocated resources, so some care must be taken, but it seems to work nicely.
2022-04-03 02:11:28 +00:00
int ret = !cexpr_eval_string (inheritstr, &ectx);
if (ret) {
ret = PL_ParseStruct (field->data, inheritItem, data, messages,
context);
}
return ret;
}
[vulkan] Support Vulkan's pNext in vkparse/vkgen The real reason for the delay in implementing support for pNext is I didn't know how to approach it at the time, but with the experience I've gained using and modifying vkparse, the solution turned out to be fairly simple. This allows for the use of various extensions (eg, multiview, which was used for testing, though none of the hookup is in this commit). No checking is done on the struct type being valid other than it must be of a chainable type (ie, have its own pNext).
2022-05-29 12:53:38 +00:00
static hashtab_t *parser_table;
static int
parse_next (const plfield_t *field, const plitem_t *item, void *data,
plitem_t *messages, void *context)
{
const char *type_name = PL_String (PL_ObjectAtIndex (item, 0));
plitem_t *next_def = PL_ObjectAtIndex (item, 1);
if (!type_name || PL_Type (next_def) != QFDictionary) {
PL_Message (messages, item, "invalid @next");
return 0;
}
parserref_t *parser = Hash_Find (parser_table, type_name);
if (!parser) {
PL_Message (messages, item, "Invalid type for @next: %s", type_name);
return 0;
}
void *data_ptr = vkparse_alloc (context, parser->size);
memset (data_ptr, 0, parser->size);
if (!parser->parse (field, next_def, data_ptr, messages, context)) {
return 0;
}
*(void **) data = data_ptr;
return 1;
}
[vulkan] Implement pipeline layout creation It seems to work when parsing the layouts. They can be created in-line (in theory) or in a "setLayouts" node and then referenced by name.
2021-01-04 08:36:11 +00:00
static int
parse_RGBA (const plitem_t *item, void **data,
plitem_t *messages, parsectx_t *context)
{
int ret = 1;
exprctx_t ectx = *context->ectx;
exprval_t result = { &cexpr_vector, data[0] };
ectx.result = &result;
[vulkan] Set source item for cexpr errors It's always nice getting at least line numbers from an error message (even if I still have to hunt for the right source "file").
2022-05-30 07:12:42 +00:00
ectx.item = item;
[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
const char *valstr = PL_String (item);
[vulkan] Implement task function parsing This just sets up the memory block and cexpr descriptors for the parameters, parameter parsing is separate (and next). The parameters are aligned to their size.
2023-02-12 16:43:17 +00:00
//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);
[vulkan] Implement task function parsing This just sets up the memory block and cexpr descriptors for the parameters, parameter parsing is separate (and next). The parameters are aligned to their size.
2023-02-12 16:43:17 +00:00
//Sys_MaskPrintf (SYS_vulkan_parse, " "VEC4F_FMT"\n",
// 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,
[vulkan] Be more consistent with parse context naming
2022-11-23 02:34:20 +00:00
plitem_t *messages, parsectx_t *pctx)
[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
{
__auto_type handle = (VkRenderPass *) data[0];
int ret = 1;
exprctx_t ectx = *pctx->ectx;
vulkan_ctx_t *ctx = pctx->vctx;
[vulkan] Make script support objects more private This will help keep changes to the scripting system localized once things are further cleaned up.
2022-11-24 14:44:07 +00:00
scriptctx_t *sctx = ctx->script_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
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] Make script support objects more private This will help keep changes to the scripting system localized once things are further cleaned up.
2022-11-24 14:44:07 +00:00
*handle = (VkRenderPass) QFV_GetHandle (sctx->renderpasses, path);
[vulkan] Parse clear values And get the render pass working in general. Note that this is only the render pass and frame buffers: actual commands still have problems.
2021-02-23 05:37:48 +00:00
if (*handle) {
return 1;
}
plitem_t *setItem = 0;
exprval_t result = { &cexpr_plitem, &setItem };
ectx.result = &result;
[vulkan] Set source item for cexpr errors It's always nice getting at least line numbers from an error message (even if I still have to hunt for the right source "file").
2022-05-30 07:12:42 +00:00
ectx.item = 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
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);
[vulkan] Make script support objects more private This will help keep changes to the scripting system localized once things are further cleaned up.
2022-11-24 14:44:07 +00:00
QFV_AddHandle (sctx->renderpasses, 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,
[vulkan] Be more consistent with parse context naming
2022-11-23 02:34:20 +00:00
plitem_t *messages, parsectx_t *pctx)
[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] Be more consistent with parse context naming
2022-11-23 02:34:20 +00:00
vulkan_ctx_t *ctx = pctx->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] Make script support objects more private This will help keep changes to the scripting system localized once things are further cleaned up.
2022-11-24 14:44:07 +00:00
scriptctx_t *sctx = ctx->script_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] 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] Make script support objects more private This will help keep changes to the scripting system localized once things are further cleaned up.
2022-11-24 14:44:07 +00:00
*handle = (VkShaderModule) QFV_GetHandle (sctx->shaderModules, name);
[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] Add a debug stack to the vulkan instance The stack is arbitrary strings that the validation layer debug callback prints in reverse order after each message. This makes it easy to work out what nodes in a pipeline/render pass plist are causing validation errors. Still have to narrow down the actual line, but the messages seem to help with that. Putting qfvPushDebug/qfvPopDebug around other calls to vulkan should help out a lot, tool. As a bonus, the stack is printed before debug_breakpoint is called, so it's immediately visible in gdb.
2021-11-30 03:24:45 +00:00
qfvPushDebug (ctx, va (ctx->va_ctx, "parse_VkShaderModule: %d", PL_Line (item)));
*handle = QFV_CreateShaderModule (device, name);
qfvPopDebug (ctx);
if (!*handle) {
[vulkan] Rework pipeline parsing for better reuse It's not entirely there yet, but the basics are working. Work is still needed for avoiding duplication of objects (different threads will have different contexts and thus different tables, so necessary per-thread duplication should not become a problem) and general access to arbitrary fields (mostly just parsing the strings)
2021-02-04 08:03:49 +00:00
PL_Message (messages, item, "could not find shader %s", name);
[vulkan] Generate code for resource nodes This makes it easy to add resource nodes defining contextually named resources. It is already used for shaders, set layouts, and pipeline layouts.
2021-01-05 05:15:35 +00:00
return 0;
[vulkan] Clean up some tangled dependencies Dependencies on vkparse.hinc were spreading through the code which I didn't want as that removes a lot of the automation from the automake files. This keeps all parser code internal to vkparse.c's scope, and any accesses required for enum and struct (not yet) definitions can be fetched by name.
2021-01-04 08:26:39 +00:00
}
[vulkan] Make script support objects more private This will help keep changes to the scripting system localized once things are further cleaned up.
2022-11-24 14:44:07 +00:00
QFV_AddHandle (sctx->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] Make script support objects more private This will help keep changes to the scripting system localized once things are further cleaned up.
2022-11-24 14:44:07 +00:00
scriptctx_t *sctx = ctx->script_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
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] Make script support objects more private This will help keep changes to the scripting system localized once things are further cleaned up.
2022-11-24 14:44:07 +00:00
*handle = (VkDescriptorSetLayout) QFV_GetHandle (sctx->setLayouts, path);
[vulkan] Take care of the duplicate handles
2021-02-04 11:40:28 +00:00
if (*handle) {
[vulkan] Rework pipeline parsing for better reuse It's not entirely there yet, but the basics are working. Work is still needed for avoiding duplication of objects (different threads will have different contexts and thus different tables, so necessary per-thread duplication should not become a problem) and general access to arbitrary fields (mostly just parsing the strings)
2021-02-04 08:03:49 +00:00
return 1;
[vulkan] Generate code for resource nodes This makes it easy to add resource nodes defining contextually named resources. It is already used for shaders, set layouts, and pipeline layouts.
2021-01-05 05:15:35 +00:00
}
[vulkan] Rework pipeline parsing for better reuse It's not entirely there yet, but the basics are working. Work is still needed for avoiding duplication of objects (different threads will have different contexts and thus different tables, so necessary per-thread duplication should not become a problem) and general access to arbitrary fields (mostly just parsing the strings)
2021-02-04 08:03:49 +00:00
plitem_t *setItem = 0;
exprval_t result = { &cexpr_plitem, &setItem };
ectx.result = &result;
[vulkan] Set source item for cexpr errors It's always nice getting at least line numbers from an error message (even if I still have to hunt for the right source "file").
2022-05-30 07:12:42 +00:00
ectx.item = 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
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);
[vulkan] Make script support objects more private This will help keep changes to the scripting system localized once things are further cleaned up.
2022-11-24 14:44:07 +00:00
QFV_AddHandle (sctx->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,
[vulkan] Be more consistent with parse context naming
2022-11-23 02:34:20 +00:00
plitem_t *messages, parsectx_t *pctx)
[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] Be more consistent with parse context naming
2022-11-23 02:34:20 +00:00
exprctx_t ectx = *pctx->ectx;
vulkan_ctx_t *ctx = pctx->vctx;
[vulkan] Make script support objects more private This will help keep changes to the scripting system localized once things are further cleaned up.
2022-11-24 14:44:07 +00:00
scriptctx_t *sctx = ctx->script_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
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] Make script support objects more private This will help keep changes to the scripting system localized once things are further cleaned up.
2022-11-24 14:44:07 +00:00
*handle = (VkPipelineLayout) QFV_GetHandle (sctx->pipelineLayouts, path);
[vulkan] Take care of the duplicate handles
2021-02-04 11:40:28 +00:00
if (*handle) {
[vulkan] Rework pipeline parsing for better reuse It's not entirely there yet, but the basics are working. Work is still needed for avoiding duplication of objects (different threads will have different contexts and thus different tables, so necessary per-thread duplication should not become a problem) and general access to arbitrary fields (mostly just parsing the strings)
2021-02-04 08:03:49 +00:00
return 1;
}
plitem_t *setItem = 0;
exprval_t result = { &cexpr_plitem, &setItem };
ectx.result = &result;
[vulkan] Set source item for cexpr errors It's always nice getting at least line numbers from an error message (even if I still have to hunt for the right source "file").
2022-05-30 07:12:42 +00:00
ectx.item = 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
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] Be more consistent with parse context naming
2022-11-23 02:34:20 +00:00
layout = QFV_ParsePipelineLayout (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 = (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);
[vulkan] Make script support objects more private This will help keep changes to the scripting system localized once things are further cleaned up.
2022-11-24 14:44:07 +00:00
QFV_AddHandle (sctx->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] Support parsing qfv_output_t This will be needed by the revamped render pass code.
2022-11-26 13:22:22 +00:00
exprtype_t VkImage_type = {
.name = "VkImage",
.size = sizeof (VkImage),
.binops = 0,
.unops = 0,
.data = 0
};
exprtype_t VkImageView_type = {
.name = "VkImageView",
.size = sizeof (VkImageView),
.binops = 0,
.unops = 0,
.data = 0
};
[vulkan] Start moving towards a deferred renderer After getting lights even vaguely working for alias models, I realized that it just wasn't going to be feasible to do nice lighting with forward rendering. This gets the bulk of the work done for deferred rendering, but still need to sort out the shaders before any real testing can be done.
2021-02-14 02:35:06 +00:00
static int
parse_VkImage (const plitem_t *item, void **data, plitem_t *messages,
[vulkan] Be more consistent with parse context naming
2022-11-23 02:34:20 +00:00
parsectx_t *pctx)
[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
{
__auto_type handle = (VkImage *) data[0];
int ret = 1;
[vulkan] Be more consistent with parse context naming
2022-11-23 02:34:20 +00:00
exprctx_t ectx = *pctx->ectx;
vulkan_ctx_t *ctx = pctx->vctx;
[vulkan] Make script support objects more private This will help keep changes to the scripting system localized once things are further cleaned up.
2022-11-24 14:44:07 +00:00
scriptctx_t *sctx = ctx->script_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
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] Make script support objects more private This will help keep changes to the scripting system localized once things are further cleaned up.
2022-11-24 14:44:07 +00:00
*handle = (VkImage) QFV_GetHandle (sctx->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;
}
[vulkan] Support parsing qfv_output_t This will be needed by the revamped render pass code.
2022-11-26 13:22:22 +00:00
exprval_t result = { };
[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
ectx.result = &result;
[vulkan] Set source item for cexpr errors It's always nice getting at least line numbers from an error message (even if I still have to hunt for the right source "file").
2022-05-30 07:12:42 +00:00
ectx.item = 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
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) {
[vulkan] Support parsing qfv_output_t This will be needed by the revamped render pass code.
2022-11-26 13:22:22 +00:00
if (result.type == &cexpr_plitem) {
plitem_t *imageItem = *(plitem_t **) result.value;
VkImage image;
image = QFV_ParseImage (ctx, imageItem, pctx->properties);
*handle = (VkImage) 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
[vulkan] Support parsing qfv_output_t This will be needed by the revamped render pass code.
2022-11-26 13:22:22 +00:00
// path not guaranteed to survive cexpr_eval_string due to va
path = resource_path (ctx, "images", name);
QFV_AddHandle (sctx->images, path, (uint64_t) image);
} else if (result.type == &VkImage_type) {
*handle = *(VkImage *) result.value;
} else {
ret = 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
}
return ret;
}
static int
parse_VkImageView (const plfield_t *field, const plitem_t *item, void *data,
[vulkan] Be more consistent with parse context naming
2022-11-23 02:34:20 +00:00
plitem_t *messages, void *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
{
[vulkan] Be more consistent with parse context naming
2022-11-23 02:34:20 +00:00
parsectx_t *pctx = 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
__auto_type handle = (VkImageView *) data;
int ret = 1;
[vulkan] Be more consistent with parse context naming
2022-11-23 02:34:20 +00:00
exprctx_t ectx = *pctx->ectx;
vulkan_ctx_t *ctx = pctx->vctx;
[vulkan] Make script support objects more private This will help keep changes to the scripting system localized once things are further cleaned up.
2022-11-24 14:44:07 +00:00
scriptctx_t *sctx = ctx->script_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
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] Make script support objects more private This will help keep changes to the scripting system localized once things are further cleaned up.
2022-11-24 14:44:07 +00:00
*handle = (VkImageView) QFV_GetHandle (sctx->imageViews, path);
[vulkan] Start moving towards a deferred renderer After getting lights even vaguely working for alias models, I realized that it just wasn't going to be feasible to do nice lighting with forward rendering. This gets the bulk of the work done for deferred rendering, but still need to sort out the shaders before any real testing can be done.
2021-02-14 02:35:06 +00:00
if (*handle) {
return 1;
}
exprval_t *value = 0;
exprval_t result = { &cexpr_exprval, &value };
ectx.result = &result;
[vulkan] Set source item for cexpr errors It's always nice getting at least line numbers from an error message (even if I still have to hunt for the right source "file").
2022-05-30 07:12:42 +00:00
ectx.item = 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
ret = !cexpr_eval_string (path, &ectx);
[vulkan] Start moving towards a deferred renderer After getting lights even vaguely working for alias models, I realized that it just wasn't going to be feasible to do nice lighting with forward rendering. This gets the bulk of the work done for deferred rendering, but still need to sort out the shaders before any real testing can be done.
2021-02-14 02:35:06 +00:00
plitem_t *imageViewItem = 0;
if (ret) {
VkImageView imageView;
[vulkan] Break render pass parsing away from swapchain This allows a single render pass description to be used for both on-screen and off-screen targets. While Vulkan does allow a VkRenderPass to be used with any compatible frame buffer, and vkparse caches a VkRenderPass created from the same description, this allows the same description to be used for a compatible off-screen target without any dependence on the swapchain. However, there is a problem in the caching when it comes to targeting outputs with different formats.
2022-04-02 02:42:36 +00:00
if (value->type == &VkImageView_type) {
[vulkan] Start moving towards a deferred renderer After getting lights even vaguely working for alias models, I realized that it just wasn't going to be feasible to do nice lighting with forward rendering. This gets the bulk of the work done for deferred rendering, but still need to sort out the shaders before any real testing can be done.
2021-02-14 02:35:06 +00:00
imageView = *(VkImageView *) value->value;
} else if (value->type == &cexpr_plitem) {
imageView = QFV_ParseImageView (ctx, imageViewItem,
[vulkan] Be more consistent with parse context naming
2022-11-23 02:34:20 +00:00
pctx->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);
[vulkan] Make script support objects more private This will help keep changes to the scripting system localized once things are further cleaned up.
2022-11-24 14:44:07 +00:00
QFV_AddHandle (sctx->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] Make script support objects more private This will help keep changes to the scripting system localized once things are further cleaned up.
2022-11-24 14:44:07 +00:00
scriptctx_t *sctx = _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
__auto_type handleref = (handleref_t *) hr;
__auto_type layout = (VkDescriptorSetLayout) handleref->handle;
[vulkan] Make script support objects more private This will help keep changes to the scripting system localized once things are further cleaned up.
2022-11-24 14:44:07 +00:00
__auto_type ctx = sctx->vctx;
[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)
{
[vulkan] Make script support objects more private This will help keep changes to the scripting system localized once things are further cleaned up.
2022-11-24 14:44:07 +00:00
scriptctx_t *sctx = _ctx;
[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
__auto_type handleref = (handleref_t *) hr;
__auto_type module = (VkShaderModule) handleref->handle;
[vulkan] Make script support objects more private This will help keep changes to the scripting system localized once things are further cleaned up.
2022-11-24 14:44:07 +00:00
__auto_type ctx = sctx->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
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)
{
[vulkan] Make script support objects more private This will help keep changes to the scripting system localized once things are further cleaned up.
2022-11-24 14:44:07 +00:00
scriptctx_t *sctx = _ctx;
[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
__auto_type handleref = (handleref_t *) hr;
__auto_type layout = (VkPipelineLayout) handleref->handle;
[vulkan] Make script support objects more private This will help keep changes to the scripting system localized once things are further cleaned up.
2022-11-24 14:44:07 +00:00
__auto_type ctx = sctx->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
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)
{
[vulkan] Make script support objects more private This will help keep changes to the scripting system localized once things are further cleaned up.
2022-11-24 14:44:07 +00:00
scriptctx_t *sctx = _ctx;
[vulkan] Parse descriptor pools
2021-01-09 16:53:15 +00:00
__auto_type handleref = (handleref_t *) hr;
__auto_type pool = (VkDescriptorPool) handleref->handle;
[vulkan] Make script support objects more private This will help keep changes to the scripting system localized once things are further cleaned up.
2022-11-24 14:44:07 +00:00
__auto_type ctx = sctx->vctx;
[vulkan] Parse descriptor pools
2021-01-09 16:53:15 +00:00
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)
{
[vulkan] Make script support objects more private This will help keep changes to the scripting system localized once things are further cleaned up.
2022-11-24 14:44:07 +00:00
scriptctx_t *sctx = _ctx;
[vulkan] Parse sampler definitions
2021-01-10 06:50:24 +00:00
__auto_type handleref = (handleref_t *) hr;
__auto_type sampler = (VkSampler) handleref->handle;
[vulkan] Make script support objects more private This will help keep changes to the scripting system localized once things are further cleaned up.
2022-11-24 14:44:07 +00:00
__auto_type ctx = sctx->vctx;
[vulkan] Parse sampler definitions
2021-01-10 06:50:24 +00:00
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)
{
[vulkan] Make script support objects more private This will help keep changes to the scripting system localized once things are further cleaned up.
2022-11-24 14:44:07 +00:00
scriptctx_t *sctx = _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
__auto_type handleref = (handleref_t *) hr;
__auto_type image = (VkImage) handleref->handle;
[vulkan] Make script support objects more private This will help keep changes to the scripting system localized once things are further cleaned up.
2022-11-24 14:44:07 +00:00
__auto_type ctx = sctx->vctx;
[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_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)
{
[vulkan] Make script support objects more private This will help keep changes to the scripting system localized once things are further cleaned up.
2022-11-24 14:44:07 +00:00
scriptctx_t *sctx = _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
__auto_type handleref = (handleref_t *) hr;
__auto_type imageView = (VkImageView) handleref->handle;
[vulkan] Make script support objects more private This will help keep changes to the scripting system localized once things are further cleaned up.
2022-11-24 14:44:07 +00:00
__auto_type ctx = sctx->vctx;
[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_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)
{
[vulkan] Make script support objects more private This will help keep changes to the scripting system localized once things are further cleaned up.
2022-11-24 14:44:07 +00:00
scriptctx_t *sctx = _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
__auto_type handleref = (handleref_t *) hr;
__auto_type renderpass = (VkRenderPass) handleref->handle;
[vulkan] Make script support objects more private This will help keep changes to the scripting system localized once things are further cleaned up.
2022-11-24 14:44:07 +00:00
__auto_type ctx = sctx->vctx;
[vulkan] Parse clear values And get the render pass working in general. Note that this is only the render pass and frame buffers: actual commands still have problems.
2021-02-23 05:37:48 +00:00
qfv_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,
[vulkan] Be more consistent with parse context naming
2022-11-23 02:34:20 +00:00
plitem_t *messages, parsectx_t *pctx)
[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
{
*(VkPipeline *) data = 0;
PL_Message (messages, item, "not implemented");
return 0;
[vulkan] Implement pipeline layout creation It seems to work when parsing the layouts. They can be created in-line (in theory) or in a "setLayouts" node and then referenced by name.
2021-01-04 08:36:11 +00:00
}
[vulkan] Ease writing of specialization data While using binary data objects for specialization data works for bools (as they can be 0 or -1), they don't work so well for numeric values due to having to get the byte order correct and thus are not portable, and difficult to get right. Binary data is still supported, but the data can be written as a string with an array(...) "constructor" expression taking any number of parameters, with each parameter itself being an expression (though values are limited at this stage). Due to the plist format, quotes are required around the expression ("array(...)")
2021-12-01 05:49:23 +00:00
typedef struct data_array_s DARRAY_TYPE(byte) data_array_t;
static void
data_array (const exprval_t **params, exprval_t *result, exprctx_t *context)
{
size_t offset = 0;
[vulkan] Copy array() parameters correctly I had forgotten that the parameters are in reverse order, and even if I had remembered, I forgot to reset offset before the second loop. Pre-decrementing offset takes care of both issues at once.
2021-12-06 10:29:37 +00:00
// params are in reverse order, but this works for calculating the size
// of the buffer
[vulkan] Ease writing of specialization data While using binary data objects for specialization data works for bools (as they can be 0 or -1), they don't work so well for numeric values due to having to get the byte order correct and thus are not portable, and difficult to get right. Binary data is still supported, but the data can be written as a string with an array(...) "constructor" expression taking any number of parameters, with each parameter itself being an expression (though values are limited at this stage). Due to the plist format, quotes are required around the expression ("array(...)")
2021-12-01 05:49:23 +00:00
for (const exprval_t **param = params; *param; param++) {
offset += (*param)->type->size;
}
__auto_type data = DARRAY_ALLOCFIXED_OBJ (data_array_t, offset,
cmemalloc, context->memsuper);
for (const exprval_t **param = params; *param; param++) {
size_t size = (*param)->type->size;
[vulkan] Copy array() parameters correctly I had forgotten that the parameters are in reverse order, and even if I had remembered, I forgot to reset offset before the second loop. Pre-decrementing offset takes care of both issues at once.
2021-12-06 10:29:37 +00:00
// pre-decrement offset because params are in reverse order
offset -= size;
[vulkan] Ease writing of specialization data While using binary data objects for specialization data works for bools (as they can be 0 or -1), they don't work so well for numeric values due to having to get the byte order correct and thus are not portable, and difficult to get right. Binary data is still supported, but the data can be written as a string with an array(...) "constructor" expression taking any number of parameters, with each parameter itself being an expression (though values are limited at this stage). Due to the plist format, quotes are required around the expression ("array(...)")
2021-12-01 05:49:23 +00:00
memcpy (data->a + offset, (*param)->value, size);
}
*(data_array_t **) result->value = data;
}
static exprtype_t data_array_type = {
[cexpr] Require designated initializers for exprtype_t This will make expanding it much safer in the future.
2022-04-24 05:55:35 +00:00
.name = "array",
.size = sizeof (data_array_t *),
.binops = 0,
.unops = 0,
[vulkan] Ease writing of specialization data While using binary data objects for specialization data works for bools (as they can be 0 or -1), they don't work so well for numeric values due to having to get the byte order correct and thus are not portable, and difficult to get right. Binary data is still supported, but the data can be written as a string with an array(...) "constructor" expression taking any number of parameters, with each parameter itself being an expression (though values are limited at this stage). Due to the plist format, quotes are required around the expression ("array(...)")
2021-12-01 05:49:23 +00:00
};
static exprfunc_t data_array_func[] = {
{ &data_array_type, -1, 0, data_array },
{}
};
static exprsym_t data_array_symbols[] = {
{ "array", &cexpr_function, data_array_func },
{}
};
static exprtab_t data_array_symtab = {
data_array_symbols,
};
static int
parse_specialization_data (const plitem_t *item, void **data,
[vulkan] Be more consistent with parse context naming
2022-11-23 02:34:20 +00:00
plitem_t *messages, parsectx_t *pctx)
[vulkan] Ease writing of specialization data While using binary data objects for specialization data works for bools (as they can be 0 or -1), they don't work so well for numeric values due to having to get the byte order correct and thus are not portable, and difficult to get right. Binary data is still supported, but the data can be written as a string with an array(...) "constructor" expression taking any number of parameters, with each parameter itself being an expression (though values are limited at this stage). Due to the plist format, quotes are required around the expression ("array(...)")
2021-12-01 05:49:23 +00:00
{
size_t *size_ptr = (size_t *) data[0];
void **data_ptr = (void **) data[1];
if (PL_Type (item) == QFBinary) {
const void *bindata = PL_BinaryData (item);
size_t binsize = PL_BinarySize (item);
[vulkan] Be more consistent with parse context naming
2022-11-23 02:34:20 +00:00
*data_ptr = vkparse_alloc (pctx, binsize);
[vulkan] Ease writing of specialization data While using binary data objects for specialization data works for bools (as they can be 0 or -1), they don't work so well for numeric values due to having to get the byte order correct and thus are not portable, and difficult to get right. Binary data is still supported, but the data can be written as a string with an array(...) "constructor" expression taking any number of parameters, with each parameter itself being an expression (though values are limited at this stage). Due to the plist format, quotes are required around the expression ("array(...)")
2021-12-01 05:49:23 +00:00
memcpy (*data_ptr, bindata, binsize);
*size_ptr = binsize;
return 1;
}
data_array_t *da= 0;
[vulkan] Be more consistent with parse context naming
2022-11-23 02:34:20 +00:00
exprctx_t ectx = *pctx->ectx;
[vulkan] Ease writing of specialization data While using binary data objects for specialization data works for bools (as they can be 0 or -1), they don't work so well for numeric values due to having to get the byte order correct and thus are not portable, and difficult to get right. Binary data is still supported, but the data can be written as a string with an array(...) "constructor" expression taking any number of parameters, with each parameter itself being an expression (though values are limited at this stage). Due to the plist format, quotes are required around the expression ("array(...)")
2021-12-01 05:49:23 +00:00
exprval_t result = { &data_array_type, &da };
[vulkan] Be more consistent with parse context naming
2022-11-23 02:34:20 +00:00
ectx.parent = pctx->ectx;
[vulkan] Ease writing of specialization data While using binary data objects for specialization data works for bools (as they can be 0 or -1), they don't work so well for numeric values due to having to get the byte order correct and thus are not portable, and difficult to get right. Binary data is still supported, but the data can be written as a string with an array(...) "constructor" expression taking any number of parameters, with each parameter itself being an expression (though values are limited at this stage). Due to the plist format, quotes are required around the expression ("array(...)")
2021-12-01 05:49:23 +00:00
ectx.symtab = &data_array_symtab;
ectx.result = &result;
[vulkan] Set source item for cexpr errors It's always nice getting at least line numbers from an error message (even if I still have to hunt for the right source "file").
2022-05-30 07:12:42 +00:00
ectx.item = item;
[vulkan] Ease writing of specialization data While using binary data objects for specialization data works for bools (as they can be 0 or -1), they don't work so well for numeric values due to having to get the byte order correct and thus are not portable, and difficult to get right. Binary data is still supported, but the data can be written as a string with an array(...) "constructor" expression taking any number of parameters, with each parameter itself being an expression (though values are limited at this stage). Due to the plist format, quotes are required around the expression ("array(...)")
2021-12-01 05:49:23 +00:00
const char *valstr = PL_String (item);
//Sys_MaskPrintf (SYS_vulkan_parse,
// "parse_specialization_data: %s %zd %d %p %p %s\n",
// field->name, field->offset, field->type, field->parser,
// field->data, valstr);
int ret = !cexpr_eval_string (valstr, &ectx);
if (!ret) {
PL_Message (messages, item, "error parsing specialization data: %s",
valstr);
} else {
*size_ptr = da->size;
*data_ptr = da->a;
[vulkan] Copy array() parameters correctly I had forgotten that the parameters are in reverse order, and even if I had remembered, I forgot to reset offset before the second loop. Pre-decrementing offset takes care of both issues at once.
2021-12-06 10:29:37 +00:00
//for (size_t i = 0; i < da->size; i++) {
// Sys_Printf (" %02x", da->a[i]);
//}
//Sys_Printf ("\n");
[vulkan] Ease writing of specialization data While using binary data objects for specialization data works for bools (as they can be 0 or -1), they don't work so well for numeric values due to having to get the byte order correct and thus are not portable, and difficult to get right. Binary data is still supported, but the data can be written as a string with an array(...) "constructor" expression taking any number of parameters, with each parameter itself being an expression (though values are limited at this stage). Due to the plist format, quotes are required around the expression ("array(...)")
2021-12-01 05:49:23 +00:00
}
return ret;
}
[vulkan] Generate parse data for new render pass structs There's still a lot of work to do, but the basics are in. The spec will be parsed into info structs that can then be further processed to generate all the actual structs, generally making things a little less timing dependent (eg, image view info refers to its image by name). The new render pass and subpass structs have their names mangled for now until I can switch over to the new system.
2023-02-09 05:52:43 +00:00
static int
parse_task_function (const plitem_t *item, void **data,
plitem_t *messages, parsectx_t *pctx)
{
[vulkan] Implement task function parsing This just sets up the memory block and cexpr descriptors for the parameters, parameter parsing is separate (and next). The parameters are aligned to their size.
2023-02-12 16:43:17 +00:00
qfv_renderctx_t *rctx = pctx->data;
const char *fname = PL_String (item);
[vulkan] Create a render context This gets an empty (no tasks or pipelines connected) render context initialized and available for other subsystems to register their task functions. Nothing is using it yet, but the test parse of rp_main_def fails gracefully (needs those tasks).
2023-02-13 08:45:36 +00:00
exprsym_t *fsym = Hash_Find (rctx->task_functions.tab, fname);
[vulkan] Implement task function parsing This just sets up the memory block and cexpr descriptors for the parameters, parameter parsing is separate (and next). The parameters are aligned to their size.
2023-02-12 16:43:17 +00:00
if (!fsym) {
PL_Message (messages, item, "undefined task function %s", fname);
return 0;
}
if (fsym->type != &cexpr_function) {
PL_Message (messages, item, "not a function type %s", fname);
return 0;
}
exprfunc_t *func;
for (func = fsym->value; func->func; func++) {
if (!func->result) {
break;
}
}
if (!func->func) {
PL_Message (messages, item, "%s does not have a void implementation",
fname);
return 0;
}
size_t size = func->num_params * sizeof (exprval_t);
size += func->num_params * sizeof (exprval_t *);
size_t base = size;
for (int i = 0; i < func->num_params; i++) {
exprtype_t *type = func->param_types[i];
size = ((size + type->size - 1) & ~(type->size - 1));
if (i == 0) {
base = size;
}
}
exprval_t **param_ptrs = vkparse_alloc (pctx, size);
exprval_t *params = (exprval_t *) &param_ptrs[func->num_params];
byte *param_data = (byte *) param_ptrs + base;
memset (params, 0, size);
size_t offs = 0;
for (int i = 0; i < func->num_params; i++) {
exprtype_t *type = func->param_types[i];
param_ptrs[i] = &params[i];
params[i] = (exprval_t) {
.type = type,
.value = param_data + offs,
};
offs = ((offs + type->size - 1) & ~(type->size - 1));
offs += type->size;
}
*(exprfunc_t **) data[0] = func;
*(exprval_t ***) data[1] = param_ptrs;
*(void **) data[2] = param_data;
return 1;
[vulkan] Generate parse data for new render pass structs There's still a lot of work to do, but the basics are in. The spec will be parsed into info structs that can then be further processed to generate all the actual structs, generally making things a little less timing dependent (eg, image view info refers to its image by name). The new render pass and subpass structs have their names mangled for now until I can switch over to the new system.
2023-02-09 05:52:43 +00:00
}
static int
parse_task_params (const plitem_t *item, void **data,
plitem_t *messages, parsectx_t *pctx)
{
[vulkan] Implement task parameter parsing This should fill in the task function's parameters nicely. The parameter count check is known to work.
2023-02-13 02:30:14 +00:00
exprfunc_t *func = *(exprfunc_t **) data[0];
exprval_t **params = *(exprval_t ***) data[1];
[vulkan] Create a render context This gets an empty (no tasks or pipelines connected) render context initialized and available for other subsystems to register their task functions. Nothing is using it yet, but the test parse of rp_main_def fails gracefully (needs those tasks).
2023-02-13 08:45:36 +00:00
if (!func) {
PL_Message (messages, item, "task function not set");
return 0;
}
[vulkan] Implement task parameter parsing This should fill in the task function's parameters nicely. The parameter count check is known to work.
2023-02-13 02:30:14 +00:00
if (PL_A_NumObjects (item) != func->num_params) {
PL_Message (messages, item, "incorrect number of parameters");
return 0;
}
for (int i = 0; i < func->num_params; i++) {
const char *paramstr = PL_String (PL_ObjectAtIndex (item, i));
exprval_t *param = params[func->num_params - i - 1];
exprctx_t ectx = *pctx->ectx;
if (param->type->data) {
ectx.parent = pctx->ectx;
ectx.symtab = ((exprenum_t *) param->type->data)->symtab;
}
// cexpr params are in reverse order
ectx.result = param;
if (cexpr_eval_string (paramstr, &ectx)) {
PL_Message (messages, item, "error parsing param %d", i);
return 0;
}
}
return 1;
[vulkan] Generate parse data for new render pass structs There's still a lot of work to do, but the basics are in. The spec will be parsed into info structs that can then be further processed to generate all the actual structs, generally making things a little less timing dependent (eg, image view info refers to its image by name). The new render pass and subpass structs have their names mangled for now until I can switch over to the new system.
2023-02-09 05:52:43 +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] Rename vulkan_framebuffer_t It turns out I had conflated frame buffers with frames and wound up making a minor mess when separating the number of frames the renderer could have in flight from the number of swap-chain images. This is the first step towards correcting that mistake.
2021-02-05 01:22:32 +00:00
static exprsym_t vulkan_frameset_t_symbols[] = {
{"size", &cexpr_size_t, (void *)field_offset (vulkan_frameset_t, size)},
[vulkan] Make frame-buffer count available to It turns out I made a bit of a mistake in tying the frame-buffer count to the number of swapchain images. This is the first step in sorting that out.
2021-01-16 12:03:36 +00:00
{ }
};
[vulkan] Rename vulkan_framebuffer_t It turns out I had conflated frame buffers with frames and wound up making a minor mess when separating the number of frames the renderer could have in flight from the number of swap-chain images. This is the first step towards correcting that mistake.
2021-02-05 01:22:32 +00:00
static exprtab_t vulkan_frameset_t_symtab = {
vulkan_frameset_t_symbols,
[vulkan] Make frame-buffer count available to It turns out I made a bit of a mistake in tying the frame-buffer count to the number of swapchain images. This is the first step in sorting that out.
2021-01-16 12:03:36 +00:00
};
[vulkan] Rename vulkan_framebuffer_t It turns out I had conflated frame buffers with frames and wound up making a minor mess when separating the number of frames the renderer could have in flight from the number of swap-chain images. This is the first step towards correcting that mistake.
2021-02-05 01:22:32 +00:00
exprtype_t vulkan_frameset_t_type = {
[cexpr] Require designated initializers for exprtype_t This will make expanding it much safer in the future.
2022-04-24 05:55:35 +00:00
.name = "frameset",
.size = sizeof (vulkan_frameset_t *),
.binops = cexpr_struct_binops,
.unops = 0,
.data = &vulkan_frameset_t_symtab,
[vulkan] Make frame-buffer count available to It turns out I made a bit of a mistake in tying the frame-buffer count to the number of swapchain images. This is the first step in sorting that out.
2021-01-16 12:03:36 +00:00
};
[vulkan] Parse sampler definitions
2021-01-10 06:50:24 +00:00
static hashtab_t *
[vulkan] Make script support objects more private This will help keep changes to the scripting system localized once things are further cleaned up.
2022-11-24 14:44:07 +00:00
handlref_symtab (void (*free_func)(void*,void*), scriptctx_t *sctx)
[vulkan] Parse sampler definitions
2021-01-10 06:50:24 +00:00
{
[vulkan] Make script support objects more private This will help keep changes to the scripting system localized once things are further cleaned up.
2022-11-24 14:44:07 +00:00
return Hash_NewTable (23, handleref_getkey, free_func, sctx,
&sctx->hashctx);
[vulkan] Parse sampler definitions
2021-01-10 06:50:24 +00:00
}
[vulkan] Implement pipeline creation The prototypes for handle parsers needed to be changes because it turned out "single" was inappropriate for handles as "single" allocates memory for the parsed object, but handles must be written directly.
2021-01-05 14:42:30 +00:00
static const char *
enum_symtab_getkey (const void *e, void *unused)
{
__auto_type enm = (const exprenum_t *) e;
return enm->type->name;
}
[vulkan] Support Vulkan's pNext in vkparse/vkgen The real reason for the delay in implementing support for pNext is I didn't know how to approach it at the time, but with the experience I've gained using and modifying vkparse, the solution turned out to be fairly simple. This allows for the use of various extensions (eg, multiview, which was used for testing, though none of the hookup is in this commit). No checking is done on the struct type being valid other than it must be of a chainable type (ie, have its own pNext).
2022-05-29 12:53:38 +00:00
static const char *
parser_getkey (const void *e, void *unused)
{
__auto_type parser = (const parserref_t *) e;
return parser->name;
}
[vulkan] Connect up the cexpr library This will make property list expressions easier to work with. The library is rather limited right now (trig, dot, min/max/bound) but even just min adds a lot of functionality.
2021-12-04 05:09:57 +00:00
static exprtab_t root_symtab = {
.symbols = cexpr_lib_symbols,
};
[vulkan] Fix some memory leaks And deal with a shutdown order issue causing cvars to crash on shutdown (due to the hash links being freed too early).
2023-03-05 09:19:54 +00:00
static void
root_symtab_shutdown (void *data)
{
Hash_DelTable (root_symtab.tab);
}
[vulkan] Connect up the cexpr library This will make property list expressions easier to work with. The library is rather limited right now (trig, dot, min/max/bound) but even just min adds a lot of functionality.
2021-12-04 05:09:57 +00:00
static void __attribute__((constructor))
root_symtab_init (void)
{
[hash] Rename the publicly visible hashlink_t to hashctx_t I think my biggest problem with the hashlink freelist parameter was how much implementation it exposed in just the name.
2022-05-12 08:54:23 +00:00
// using a null hashctx here is safe because this function is run before
[vulkan] Connect up the cexpr library This will make property list expressions easier to work with. The library is rather limited right now (trig, dot, min/max/bound) but even just min adds a lot of functionality.
2021-12-04 05:09:57 +00:00
// main and thus before any possibility of threading.
exprctx_t root_context = { .symtab = &root_symtab };
cexpr_init_symtab (&root_symtab, &root_context);
[vulkan] Fix some memory leaks And deal with a shutdown order issue causing cvars to crash on shutdown (due to the hash links being freed too early).
2023-03-05 09:19:54 +00:00
Sys_RegisterShutdown (root_symtab_shutdown, 0);
[vulkan] Connect up the cexpr library This will make property list expressions easier to work with. The library is rather limited right now (trig, dot, min/max/bound) but even just min adds a lot of functionality.
2021-12-04 05:09:57 +00:00
}
[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
{
[vulkan] Make script support objects more private This will help keep changes to the scripting system localized once things are further cleaned up.
2022-11-24 14:44:07 +00:00
scriptctx_t *sctx = ctx->script_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
plitem_t *messages = PL_NewArray ();
[vulkan] Connect up the cexpr library This will make property list expressions easier to work with. The library is rather limited right now (trig, dot, min/max/bound) but even just min adds a lot of functionality.
2021-12-04 05:09:57 +00:00
exprctx_t exprctx = { .symtab = &root_symtab };
[vulkan] Start moving towards a deferred renderer After getting lights even vaguely working for alias models, I realized that it just wasn't going to be feasible to do nice lighting with forward rendering. This gets the bulk of the work done for deferred rendering, but still need to sort out the shaders before any real testing can be done.
2021-02-14 02:35:06 +00:00
parsectx_t parsectx = { &exprctx, ctx, properties };
[vulkan] Hook up the expression parser The pipeline parser still isn't hooked up yet as something isn't quite right, but it seems all the parsing works.
2020-12-21 09:38:31 +00:00
exprsym_t var_syms[] = {
[vulkan] Make script support objects more private This will help keep changes to the scripting system localized once things are further cleaned up.
2022-11-24 14:44:07 +00:00
{"output", &qfv_output_t_type, &sctx->output},
[vulkan] Rename vulkan_framebuffer_t It turns out I had conflated frame buffers with frames and wound up making a minor mess when separating the number of frames the renderer could have in flight from the number of swap-chain images. This is the first step towards correcting that mistake.
2021-02-05 01:22:32 +00:00
{"frames", &vulkan_frameset_t_type, &ctx->frames},
[vulkan] Ensure msaa settings are consistent I had forgotten that msaa samples was governed by the driver (as a max) and the renderpass setup code simply took the max. Thus why 1 vs 8 caused the display to render incorrectly.
2020-12-21 11:17:27 +00:00
{"msaaSamples", &VkSampleCountFlagBits_type, &ctx->msaaSamples},
[vulkan] Provide access to VkPhysicalDeviceLimits Fixes the warning about parse_fixed_array not being used (oops, the problem with partial commits), but more importantly, gives access to things like maxDescriptorSetSamplers.
2021-12-04 05:31:39 +00:00
{"physDevLimits", &VkPhysicalDeviceLimits_type,
[vulkan] Switch to using vkGetPhysicalDeviceProperties2 Necessary for getting VkPhysicalDeviceMultiviewProperties (and others, but not at this time).
2022-05-29 13:13:36 +00:00
&ctx->device->physDev->properties->limits },
[vulkan] Start moving towards a deferred renderer After getting lights even vaguely working for alias models, I realized that it just wasn't going to be feasible to do nice lighting with forward rendering. This gets the bulk of the work done for deferred rendering, but still need to sort out the shaders before any real testing can be done.
2021-02-14 02:35:06 +00:00
{QFV_PROPERTIES, &cexpr_plitem, &parsectx.properties},
[vulkan] Hook up the expression parser The pipeline parser still isn't hooked up yet as something isn't quite right, but it seems all the parsing works.
2020-12-21 09:38:31 +00:00
{}
};
exprtab_t vars_tab = { var_syms, 0 };
[vulkan] Rework pipeline parsing for better reuse It's not entirely there yet, but the basics are working. Work is still needed for avoiding duplication of objects (different threads will have different contexts and thus different tables, so necessary per-thread duplication should not become a problem) and general access to arbitrary fields (mostly just parsing the strings)
2021-02-04 08:03:49 +00:00
exprctx.external_variables = &vars_tab;
[vulkan] Hook up the expression parser The pipeline parser still isn't hooked up yet as something isn't quite right, but it seems all the parsing works.
2020-12-21 09:38:31 +00:00
exprctx.messages = messages;
[vulkan] Make script support objects more private This will help keep changes to the scripting system localized once things are further cleaned up.
2022-11-24 14:44:07 +00:00
exprctx.hashctx = &sctx->hashctx;
Fix a pile of leaks and uninit errors Still "some" more to go: a pile to do with transforms and temporary entities, and a nasty one with host_cbuf. There's also all the static block-alloc lists :/
2021-03-21 10:56:17 +00:00
exprctx.memsuper = memsuper;
[vulkan] Rework pipeline parsing for better reuse It's not entirely there yet, but the basics are working. Work is still needed for avoiding duplication of objects (different threads will have different contexts and thus different tables, so necessary per-thread duplication should not become a problem) and general access to arbitrary fields (mostly just parsing the strings)
2021-02-04 08:03:49 +00:00
[vulkan] Hook up the expression parser The pipeline parser still isn't hooked up yet as something isn't quite right, but it seems all the parsing works.
2020-12-21 09:38:31 +00:00
cexpr_init_symtab (&vars_tab, &exprctx);
[vulkan] Start work on scripted pipeline Nothing is actually done yet other than parsing the built-in property list to property list items (the actual parser is just a skeleton), but everything compiles
2020-07-16 06:42:49 +00:00
[vulkan] Rework pipeline parsing for better reuse It's not entirely there yet, but the basics are working. Work is still needed for avoiding duplication of objects (different threads will have different contexts and thus different tables, so necessary per-thread duplication should not become a problem) and general access to arbitrary fields (mostly just parsing the strings)
2021-02-04 08:03:49 +00:00
if (!parser (0, plist, object, messages, &parsectx)) {
[vulkan] Start work on scripted pipeline Nothing is actually done yet other than parsing the built-in property list to property list items (the actual parser is just a skeleton), but everything compiles
2020-07-16 06:42:49 +00:00
for (int i = 0; i < PL_A_NumObjects (messages); i++) {
[vulkan] Fix a couple of minor issues Magic number for compose descriptors and mistaken masking of vulkan plist parse errors.
2021-04-18 11:41:08 +00:00
Sys_Printf ("%s\n", PL_String (PL_ObjectAtIndex (messages, i)));
[vulkan] Start work on scripted pipeline Nothing is actually done yet other than parsing the built-in property list to property list items (the actual parser is just a skeleton), but everything compiles
2020-07-16 06:42:49 +00:00
}
return 0;
}
Fix a pile of leaks and uninit errors Still "some" more to go: a pile to do with transforms and temporary entities, and a nasty one with host_cbuf. There's also all the static block-alloc lists :/
2021-03-21 10:56:17 +00:00
Hash_DelTable (vars_tab.tab);
[plist] Use reference counts for items This makes it much easier to share items between property lists (eg, targets and the main entity list in cl_light).
2023-03-12 06:17:28 +00:00
PL_Release (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;
}
VkRenderPass
[vulkan] Start moving towards a deferred renderer After getting lights even vaguely working for alias models, I realized that it just wasn't going to be feasible to do nice lighting with forward rendering. This gets the bulk of the work done for deferred rendering, but still need to sort out the shaders before any real testing can be done.
2021-02-14 02:35:06 +00:00
QFV_ParseRenderPass (vulkan_ctx_t *ctx, plitem_t *plist, plitem_t *properties)
[vulkan] Rework pipeline parsing for better reuse It's not entirely there yet, but the basics are working. Work is still needed for avoiding duplication of objects (different threads will have different contexts and thus different tables, so necessary per-thread duplication should not become a problem) and general access to arbitrary fields (mostly just parsing the strings)
2021-02-04 08:03:49 +00:00
{
Fix a pile of leaks and uninit errors Still "some" more to go: a pile to do with transforms and temporary entities, and a nasty one with host_cbuf. There's also all the static block-alloc lists :/
2021-03-21 10:56:17 +00:00
memsuper_t *memsuper = new_memsuper ();
[vulkan] Rework pipeline parsing for better reuse It's not entirely there yet, but the basics are working. Work is still needed for avoiding duplication of objects (different threads will have different contexts and thus different tables, so necessary per-thread duplication should not become a problem) and general access to arbitrary fields (mostly just parsing the strings)
2021-02-04 08:03:49 +00:00
qfv_device_t *device = ctx->device;
[vulkan] Parse VkRenderPass directly QFV_CreateRenderPass doesn't support pNext and I don't particularly feel like making it do so at this stage (tempted to remove it).
2022-05-29 14:15:51 +00:00
qfv_devfuncs_t *dfunc = device->funcs;
[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] Parse VkRenderPass directly QFV_CreateRenderPass doesn't support pNext and I don't particularly feel like making it do so at this stage (tempted to remove it).
2022-05-29 14:15:51 +00:00
VkRenderPassCreateInfo cInfo = {};
[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] Parse VkRenderPass directly QFV_CreateRenderPass doesn't support pNext and I don't particularly feel like making it do so at this stage (tempted to remove it).
2022-05-29 14:15:51 +00:00
if (!parse_object (ctx, memsuper, plist, parse_VkRenderPassCreateInfo,
&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;
}
VkRenderPass renderpass;
[vulkan] Parse VkRenderPass directly QFV_CreateRenderPass doesn't support pNext and I don't particularly feel like making it do so at this stage (tempted to remove it).
2022-05-29 14:15:51 +00:00
qfvPushDebug (ctx, va (ctx->va_ctx, "QFV_ParseRenderPass: %d",
PL_Line (plist)));
dfunc->vkCreateRenderPass (device->dev, &cInfo, 0, &renderpass);
[vulkan] Add a debug stack to the vulkan instance The stack is arbitrary strings that the validation layer debug callback prints in reverse order after each message. This makes it easy to work out what nodes in a pipeline/render pass plist are causing validation errors. Still have to narrow down the actual line, but the messages seem to help with that. Putting qfvPushDebug/qfvPopDebug around other calls to vulkan should help out a lot, tool. As a bonus, the stack is printed before debug_breakpoint is called, so it's immediately visible in gdb.
2021-11-30 03:24:45 +00:00
qfvPopDebug (ctx);
[vulkan] Start work on scripted pipeline Nothing is actually done yet other than parsing the built-in property list to property list items (the actual parser is just a skeleton), but everything compiles
2020-07-16 06:42:49 +00:00
Fix a pile of leaks and uninit errors Still "some" more to go: a pile to do with transforms and temporary entities, and a nasty one with host_cbuf. There's also all the static block-alloc lists :/
2021-03-21 10:56:17 +00:00
delete_memsuper (memsuper);
[vulkan] Start work on scripted pipeline Nothing is actually done yet other than parsing the built-in property list to property list items (the actual parser is just a skeleton), but everything compiles
2020-07-16 06:42:49 +00:00
return renderpass;
[vulkan] Rework pipeline parsing for better reuse It's not entirely there yet, but the basics are working. Work is still needed for avoiding duplication of objects (different threads will have different contexts and thus different tables, so necessary per-thread duplication should not become a problem) and general access to arbitrary fields (mostly just parsing the strings)
2021-02-04 08:03:49 +00:00
}
VkPipeline
[vulkan] Add support for compute shaders This needed changing Vulkan_CreatePipeline to Vulkan_CreateGraphicsPipeline for consistency (and parsing the difference from a plist seemed... not worth thinking about).
2021-12-16 14:00:17 +00:00
QFV_ParseComputePipeline (vulkan_ctx_t *ctx, plitem_t *plist,
plitem_t *properties)
{
memsuper_t *memsuper = new_memsuper ();
qfv_device_t *device = ctx->device;
__auto_type cInfo = QFV_AllocComputePipelineCreateInfoSet (1, alloca);
memset (&cInfo->a[0], 0, sizeof (cInfo->a[0]));
if (!parse_object (ctx, memsuper, plist, parse_VkComputePipelineCreateInfo,
&cInfo->a[0], properties)) {
delete_memsuper (memsuper);
return 0;
}
qfvPushDebug (ctx, va (ctx->va_ctx,
"QFV_ParseComputePipeline: %d", PL_Line (plist)));
__auto_type plSet = QFV_CreateComputePipelines (device, 0, cInfo);
qfvPopDebug (ctx);
VkPipeline pipeline = plSet->a[0];
free (plSet);
delete_memsuper (memsuper);
return pipeline;
}
VkPipeline
QFV_ParseGraphicsPipeline (vulkan_ctx_t *ctx, plitem_t *plist,
plitem_t *properties)
[vulkan] Rework pipeline parsing for better reuse It's not entirely there yet, but the basics are working. Work is still needed for avoiding duplication of objects (different threads will have different contexts and thus different tables, so necessary per-thread duplication should not become a problem) and general access to arbitrary fields (mostly just parsing the strings)
2021-02-04 08:03:49 +00:00
{
Fix a pile of leaks and uninit errors Still "some" more to go: a pile to do with transforms and temporary entities, and a nasty one with host_cbuf. There's also all the static block-alloc lists :/
2021-03-21 10:56:17 +00:00
memsuper_t *memsuper = new_memsuper ();
[vulkan] Rework pipeline parsing for better reuse It's not entirely there yet, but the basics are working. Work is still needed for avoiding duplication of objects (different threads will have different contexts and thus different tables, so necessary per-thread duplication should not become a problem) and general access to arbitrary fields (mostly just parsing the strings)
2021-02-04 08:03:49 +00:00
qfv_device_t *device = ctx->device;
__auto_type cInfo = QFV_AllocGraphicsPipelineCreateInfoSet (1, alloca);
memset (&cInfo->a[0], 0, sizeof (cInfo->a[0]));
Fix a pile of leaks and uninit errors Still "some" more to go: a pile to do with transforms and temporary entities, and a nasty one with host_cbuf. There's also all the static block-alloc lists :/
2021-03-21 10:56:17 +00:00
if (!parse_object (ctx, memsuper, plist, parse_VkGraphicsPipelineCreateInfo,
[vulkan] Start moving towards a deferred renderer After getting lights even vaguely working for alias models, I realized that it just wasn't going to be feasible to do nice lighting with forward rendering. This gets the bulk of the work done for deferred rendering, but still need to sort out the shaders before any real testing can be done.
2021-02-14 02:35:06 +00:00
&cInfo->a[0], properties)) {
Fix a pile of leaks and uninit errors Still "some" more to go: a pile to do with transforms and temporary entities, and a nasty one with host_cbuf. There's also all the static block-alloc lists :/
2021-03-21 10:56:17 +00:00
delete_memsuper (memsuper);
[vulkan] Rework pipeline parsing for better reuse It's not entirely there yet, but the basics are working. Work is still needed for avoiding duplication of objects (different threads will have different contexts and thus different tables, so necessary per-thread duplication should not become a problem) and general access to arbitrary fields (mostly just parsing the strings)
2021-02-04 08:03:49 +00:00
return 0;
}
[vulkan] Support multiple render passes Multiple render passes are needed for supporting shadow mapping, and this is a huge step towards breaking the Vulkan render free of Quake, and hopefully will lead the way for breaking the GL renderers free as well.
2021-12-02 12:58:29 +00:00
qfvPushDebug (ctx, va (ctx->va_ctx,
"QFV_ParsePipeline: %d", PL_Line (plist)));
[vulkan] Implement pipeline creation The prototypes for handle parsers needed to be changes because it turned out "single" was inappropriate for handles as "single" allocates memory for the parsed object, but handles must be written directly.
2021-01-05 14:42:30 +00:00
__auto_type plSet = QFV_CreateGraphicsPipelines (device, 0, cInfo);
[vulkan] Add a debug stack to the vulkan instance The stack is arbitrary strings that the validation layer debug callback prints in reverse order after each message. This makes it easy to work out what nodes in a pipeline/render pass plist are causing validation errors. Still have to narrow down the actual line, but the messages seem to help with that. Putting qfvPushDebug/qfvPopDebug around other calls to vulkan should help out a lot, tool. As a bonus, the stack is printed before debug_breakpoint is called, so it's immediately visible in gdb.
2021-11-30 03:24:45 +00:00
qfvPopDebug (ctx);
[vulkan] Implement pipeline creation The prototypes for handle parsers needed to be changes because it turned out "single" was inappropriate for handles as "single" allocates memory for the parsed object, but handles must be written directly.
2021-01-05 14:42:30 +00:00
VkPipeline pipeline = plSet->a[0];
free (plSet);
Fix a pile of leaks and uninit errors Still "some" more to go: a pile to do with transforms and temporary entities, and a nasty one with host_cbuf. There's also all the static block-alloc lists :/
2021-03-21 10:56:17 +00:00
delete_memsuper (memsuper);
[vulkan] Implement pipeline creation The prototypes for handle parsers needed to be changes because it turned out "single" was inappropriate for handles as "single" allocates memory for the parsed object, but handles must be written directly.
2021-01-05 14:42:30 +00:00
return pipeline;
[vulkan] Clean up some tangled dependencies Dependencies on vkparse.hinc were spreading through the code which I didn't want as that removes a lot of the automation from the automake files. This keeps all parser code internal to vkparse.c's scope, and any accesses required for enum and struct (not yet) definitions can be fetched by name.
2021-01-04 08:26:39 +00:00
}
[vulkan] Rework pipeline parsing for better reuse It's not entirely there yet, but the basics are working. Work is still needed for avoiding duplication of objects (different threads will have different contexts and thus different tables, so necessary per-thread duplication should not become a problem) and general access to arbitrary fields (mostly just parsing the strings)
2021-02-04 08:03:49 +00:00
VkDescriptorPool
[vulkan] Start moving towards a deferred renderer After getting lights even vaguely working for alias models, I realized that it just wasn't going to be feasible to do nice lighting with forward rendering. This gets the bulk of the work done for deferred rendering, but still need to sort out the shaders before any real testing can be done.
2021-02-14 02:35:06 +00:00
QFV_ParseDescriptorPool (vulkan_ctx_t *ctx, plitem_t *plist,
plitem_t *properties)
[vulkan] Rework pipeline parsing for better reuse It's not entirely there yet, but the basics are working. Work is still needed for avoiding duplication of objects (different threads will have different contexts and thus different tables, so necessary per-thread duplication should not become a problem) and general access to arbitrary fields (mostly just parsing the strings)
2021-02-04 08:03:49 +00:00
{
qfv_device_t *device = ctx->device;
qfv_devfuncs_t *dfunc = device->funcs;
Fix a pile of leaks and uninit errors Still "some" more to go: a pile to do with transforms and temporary entities, and a nasty one with host_cbuf. There's also all the static block-alloc lists :/
2021-03-21 10:56:17 +00:00
memsuper_t *memsuper = new_memsuper ();
[vulkan] Rework pipeline parsing for better reuse It's not entirely there yet, but the basics are working. Work is still needed for avoiding duplication of objects (different threads will have different contexts and thus different tables, so necessary per-thread duplication should not become a problem) and general access to arbitrary fields (mostly just parsing the strings)
2021-02-04 08:03:49 +00:00
VkDescriptorPoolCreateInfo cInfo = {};
Fix a pile of leaks and uninit errors Still "some" more to go: a pile to do with transforms and temporary entities, and a nasty one with host_cbuf. There's also all the static block-alloc lists :/
2021-03-21 10:56:17 +00:00
if (!parse_object (ctx, memsuper, plist, parse_VkDescriptorPoolCreateInfo,
&cInfo, properties)) {
delete_memsuper (memsuper);
[vulkan] Rework pipeline parsing for better reuse It's not entirely there yet, but the basics are working. Work is still needed for avoiding duplication of objects (different threads will have different contexts and thus different tables, so necessary per-thread duplication should not become a problem) and general access to arbitrary fields (mostly just parsing the strings)
2021-02-04 08:03:49 +00:00
return 0;
}
VkDescriptorPool pool;
[vulkan] Add a debug stack to the vulkan instance The stack is arbitrary strings that the validation layer debug callback prints in reverse order after each message. This makes it easy to work out what nodes in a pipeline/render pass plist are causing validation errors. Still have to narrow down the actual line, but the messages seem to help with that. Putting qfvPushDebug/qfvPopDebug around other calls to vulkan should help out a lot, tool. As a bonus, the stack is printed before debug_breakpoint is called, so it's immediately visible in gdb.
2021-11-30 03:24:45 +00:00
qfvPushDebug (ctx, va (ctx->va_ctx, "QFV_ParseDescriptorPool: %d", PL_Line (plist)));
[vulkan] Rework pipeline parsing for better reuse It's not entirely there yet, but the basics are working. Work is still needed for avoiding duplication of objects (different threads will have different contexts and thus different tables, so necessary per-thread duplication should not become a problem) and general access to arbitrary fields (mostly just parsing the strings)
2021-02-04 08:03:49 +00:00
dfunc->vkCreateDescriptorPool (device->dev, &cInfo, 0, &pool);
[vulkan] Add a debug stack to the vulkan instance The stack is arbitrary strings that the validation layer debug callback prints in reverse order after each message. This makes it easy to work out what nodes in a pipeline/render pass plist are causing validation errors. Still have to narrow down the actual line, but the messages seem to help with that. Putting qfvPushDebug/qfvPopDebug around other calls to vulkan should help out a lot, tool. As a bonus, the stack is printed before debug_breakpoint is called, so it's immediately visible in gdb.
2021-11-30 03:24:45 +00:00
qfvPopDebug (ctx);
[vulkan] Rework pipeline parsing for better reuse It's not entirely there yet, but the basics are working. Work is still needed for avoiding duplication of objects (different threads will have different contexts and thus different tables, so necessary per-thread duplication should not become a problem) and general access to arbitrary fields (mostly just parsing the strings)
2021-02-04 08:03:49 +00:00
Fix a pile of leaks and uninit errors Still "some" more to go: a pile to do with transforms and temporary entities, and a nasty one with host_cbuf. There's also all the static block-alloc lists :/
2021-03-21 10:56:17 +00:00
delete_memsuper (memsuper);
[vulkan] Rework pipeline parsing for better reuse It's not entirely there yet, but the basics are working. Work is still needed for avoiding duplication of objects (different threads will have different contexts and thus different tables, so necessary per-thread duplication should not become a problem) and general access to arbitrary fields (mostly just parsing the strings)
2021-02-04 08:03:49 +00:00
return pool;
}
VkDescriptorSetLayout
[vulkan] Start moving towards a deferred renderer After getting lights even vaguely working for alias models, I realized that it just wasn't going to be feasible to do nice lighting with forward rendering. This gets the bulk of the work done for deferred rendering, but still need to sort out the shaders before any real testing can be done.
2021-02-14 02:35:06 +00:00
QFV_ParseDescriptorSetLayout (vulkan_ctx_t *ctx, plitem_t *plist,
plitem_t *properties)
[vulkan] Rework pipeline parsing for better reuse It's not entirely there yet, but the basics are working. Work is still needed for avoiding duplication of objects (different threads will have different contexts and thus different tables, so necessary per-thread duplication should not become a problem) and general access to arbitrary fields (mostly just parsing the strings)
2021-02-04 08:03:49 +00:00
{
qfv_device_t *device = ctx->device;
qfv_devfuncs_t *dfunc = device->funcs;
Fix a pile of leaks and uninit errors Still "some" more to go: a pile to do with transforms and temporary entities, and a nasty one with host_cbuf. There's also all the static block-alloc lists :/
2021-03-21 10:56:17 +00:00
memsuper_t *memsuper = new_memsuper ();
[vulkan] Rework pipeline parsing for better reuse It's not entirely there yet, but the basics are working. Work is still needed for avoiding duplication of objects (different threads will have different contexts and thus different tables, so necessary per-thread duplication should not become a problem) and general access to arbitrary fields (mostly just parsing the strings)
2021-02-04 08:03:49 +00:00
VkDescriptorSetLayoutCreateInfo cInfo = {};
Fix a pile of leaks and uninit errors Still "some" more to go: a pile to do with transforms and temporary entities, and a nasty one with host_cbuf. There's also all the static block-alloc lists :/
2021-03-21 10:56:17 +00:00
if (!parse_object (ctx, memsuper, plist,
parse_VkDescriptorSetLayoutCreateInfo,
[vulkan] Start moving towards a deferred renderer After getting lights even vaguely working for alias models, I realized that it just wasn't going to be feasible to do nice lighting with forward rendering. This gets the bulk of the work done for deferred rendering, but still need to sort out the shaders before any real testing can be done.
2021-02-14 02:35:06 +00:00
&cInfo, properties)) {
Fix a pile of leaks and uninit errors Still "some" more to go: a pile to do with transforms and temporary entities, and a nasty one with host_cbuf. There's also all the static block-alloc lists :/
2021-03-21 10:56:17 +00:00
delete_memsuper (memsuper);
[vulkan] Rework pipeline parsing for better reuse It's not entirely there yet, but the basics are working. Work is still needed for avoiding duplication of objects (different threads will have different contexts and thus different tables, so necessary per-thread duplication should not become a problem) and general access to arbitrary fields (mostly just parsing the strings)
2021-02-04 08:03:49 +00:00
return 0;
}
VkDescriptorSetLayout setLayout;
[vulkan] Add a debug stack to the vulkan instance The stack is arbitrary strings that the validation layer debug callback prints in reverse order after each message. This makes it easy to work out what nodes in a pipeline/render pass plist are causing validation errors. Still have to narrow down the actual line, but the messages seem to help with that. Putting qfvPushDebug/qfvPopDebug around other calls to vulkan should help out a lot, tool. As a bonus, the stack is printed before debug_breakpoint is called, so it's immediately visible in gdb.
2021-11-30 03:24:45 +00:00
qfvPushDebug (ctx, va (ctx->va_ctx, "QFV_ParseDescriptorSetLayout: %d", PL_Line (plist)));
[vulkan] Rework pipeline parsing for better reuse It's not entirely there yet, but the basics are working. Work is still needed for avoiding duplication of objects (different threads will have different contexts and thus different tables, so necessary per-thread duplication should not become a problem) and general access to arbitrary fields (mostly just parsing the strings)
2021-02-04 08:03:49 +00:00
dfunc->vkCreateDescriptorSetLayout (device->dev, &cInfo, 0, &setLayout);
[vulkan] Name some more objects Shaders and descriptor set layouts.
2021-04-19 08:49:03 +00:00
QFV_duSetObjectName (device, VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT,
setLayout, va (ctx->va_ctx, "descriptorSetLayout:%d",
PL_Line (plist)));
[vulkan] Add a debug stack to the vulkan instance The stack is arbitrary strings that the validation layer debug callback prints in reverse order after each message. This makes it easy to work out what nodes in a pipeline/render pass plist are causing validation errors. Still have to narrow down the actual line, but the messages seem to help with that. Putting qfvPushDebug/qfvPopDebug around other calls to vulkan should help out a lot, tool. As a bonus, the stack is printed before debug_breakpoint is called, so it's immediately visible in gdb.
2021-11-30 03:24:45 +00:00
qfvPopDebug (ctx);
[vulkan] Rework pipeline parsing for better reuse It's not entirely there yet, but the basics are working. Work is still needed for avoiding duplication of objects (different threads will have different contexts and thus different tables, so necessary per-thread duplication should not become a problem) and general access to arbitrary fields (mostly just parsing the strings)
2021-02-04 08:03:49 +00:00
Fix a pile of leaks and uninit errors Still "some" more to go: a pile to do with transforms and temporary entities, and a nasty one with host_cbuf. There's also all the static block-alloc lists :/
2021-03-21 10:56:17 +00:00
delete_memsuper (memsuper);
[vulkan] Rework pipeline parsing for better reuse It's not entirely there yet, but the basics are working. Work is still needed for avoiding duplication of objects (different threads will have different contexts and thus different tables, so necessary per-thread duplication should not become a problem) and general access to arbitrary fields (mostly just parsing the strings)
2021-02-04 08:03:49 +00:00
return setLayout;
}
VkPipelineLayout
[vulkan] Start moving towards a deferred renderer After getting lights even vaguely working for alias models, I realized that it just wasn't going to be feasible to do nice lighting with forward rendering. This gets the bulk of the work done for deferred rendering, but still need to sort out the shaders before any real testing can be done.
2021-02-14 02:35:06 +00:00
QFV_ParsePipelineLayout (vulkan_ctx_t *ctx, plitem_t *plist,
plitem_t *properties)
[vulkan] Rework pipeline parsing for better reuse It's not entirely there yet, but the basics are working. Work is still needed for avoiding duplication of objects (different threads will have different contexts and thus different tables, so necessary per-thread duplication should not become a problem) and general access to arbitrary fields (mostly just parsing the strings)
2021-02-04 08:03:49 +00:00
{
qfv_device_t *device = ctx->device;
qfv_devfuncs_t *dfunc = device->funcs;
Fix a pile of leaks and uninit errors Still "some" more to go: a pile to do with transforms and temporary entities, and a nasty one with host_cbuf. There's also all the static block-alloc lists :/
2021-03-21 10:56:17 +00:00
memsuper_t *memsuper = new_memsuper ();
[vulkan] Rework pipeline parsing for better reuse It's not entirely there yet, but the basics are working. Work is still needed for avoiding duplication of objects (different threads will have different contexts and thus different tables, so necessary per-thread duplication should not become a problem) and general access to arbitrary fields (mostly just parsing the strings)
2021-02-04 08:03:49 +00:00
VkPipelineLayoutCreateInfo cInfo = {};
Fix a pile of leaks and uninit errors Still "some" more to go: a pile to do with transforms and temporary entities, and a nasty one with host_cbuf. There's also all the static block-alloc lists :/
2021-03-21 10:56:17 +00:00
if (!parse_object (ctx, memsuper, plist, parse_VkPipelineLayoutCreateInfo,
[vulkan] Start moving towards a deferred renderer After getting lights even vaguely working for alias models, I realized that it just wasn't going to be feasible to do nice lighting with forward rendering. This gets the bulk of the work done for deferred rendering, but still need to sort out the shaders before any real testing can be done.
2021-02-14 02:35:06 +00:00
&cInfo, properties)) {
Fix a pile of leaks and uninit errors Still "some" more to go: a pile to do with transforms and temporary entities, and a nasty one with host_cbuf. There's also all the static block-alloc lists :/
2021-03-21 10:56:17 +00:00
delete_memsuper (memsuper);
[vulkan] Rework pipeline parsing for better reuse It's not entirely there yet, but the basics are working. Work is still needed for avoiding duplication of objects (different threads will have different contexts and thus different tables, so necessary per-thread duplication should not become a problem) and general access to arbitrary fields (mostly just parsing the strings)
2021-02-04 08:03:49 +00:00
return 0;
}
VkPipelineLayout layout;
[vulkan] Add a debug stack to the vulkan instance The stack is arbitrary strings that the validation layer debug callback prints in reverse order after each message. This makes it easy to work out what nodes in a pipeline/render pass plist are causing validation errors. Still have to narrow down the actual line, but the messages seem to help with that. Putting qfvPushDebug/qfvPopDebug around other calls to vulkan should help out a lot, tool. As a bonus, the stack is printed before debug_breakpoint is called, so it's immediately visible in gdb.
2021-11-30 03:24:45 +00:00
qfvPushDebug (ctx, va (ctx->va_ctx, "QFV_ParsePipelineLayout: %d", PL_Line (plist)));
[vulkan] Rework pipeline parsing for better reuse It's not entirely there yet, but the basics are working. Work is still needed for avoiding duplication of objects (different threads will have different contexts and thus different tables, so necessary per-thread duplication should not become a problem) and general access to arbitrary fields (mostly just parsing the strings)
2021-02-04 08:03:49 +00:00
dfunc->vkCreatePipelineLayout (device->dev, &cInfo, 0, &layout);
[vulkan] Clean up misuse of va for vulkan handles The built up "path" name of the handle resource was not always surviving the intervening call to cexpr_eval_string (in particular, when other handles were created in the process of creating a handle). Rather than simply increase the number of va buffers (where would it end?), just regenerate the path when adding the new handle. It's probably quick enough, and the code is not usually not on a critical path.
2021-04-22 10:47:42 +00:00
QFV_duSetObjectName (device, VK_OBJECT_TYPE_PIPELINE_LAYOUT,
layout, va (ctx->va_ctx, "pipelineLayout:%d",
PL_Line (plist)));
[vulkan] Add a debug stack to the vulkan instance The stack is arbitrary strings that the validation layer debug callback prints in reverse order after each message. This makes it easy to work out what nodes in a pipeline/render pass plist are causing validation errors. Still have to narrow down the actual line, but the messages seem to help with that. Putting qfvPushDebug/qfvPopDebug around other calls to vulkan should help out a lot, tool. As a bonus, the stack is printed before debug_breakpoint is called, so it's immediately visible in gdb.
2021-11-30 03:24:45 +00:00
qfvPopDebug (ctx);
[vulkan] Rework pipeline parsing for better reuse It's not entirely there yet, but the basics are working. Work is still needed for avoiding duplication of objects (different threads will have different contexts and thus different tables, so necessary per-thread duplication should not become a problem) and general access to arbitrary fields (mostly just parsing the strings)
2021-02-04 08:03:49 +00:00
Fix a pile of leaks and uninit errors Still "some" more to go: a pile to do with transforms and temporary entities, and a nasty one with host_cbuf. There's also all the static block-alloc lists :/
2021-03-21 10:56:17 +00:00
delete_memsuper (memsuper);
[vulkan] Rework pipeline parsing for better reuse It's not entirely there yet, but the basics are working. Work is still needed for avoiding duplication of objects (different threads will have different contexts and thus different tables, so necessary per-thread duplication should not become a problem) and general access to arbitrary fields (mostly just parsing the strings)
2021-02-04 08:03:49 +00:00
return layout;
}
VkSampler
[vulkan] Start moving towards a deferred renderer After getting lights even vaguely working for alias models, I realized that it just wasn't going to be feasible to do nice lighting with forward rendering. This gets the bulk of the work done for deferred rendering, but still need to sort out the shaders before any real testing can be done.
2021-02-14 02:35:06 +00:00
QFV_ParseSampler (vulkan_ctx_t *ctx, plitem_t *plist, plitem_t *properties)
[vulkan] Rework pipeline parsing for better reuse It's not entirely there yet, but the basics are working. Work is still needed for avoiding duplication of objects (different threads will have different contexts and thus different tables, so necessary per-thread duplication should not become a problem) and general access to arbitrary fields (mostly just parsing the strings)
2021-02-04 08:03:49 +00:00
{
qfv_device_t *device = ctx->device;
qfv_devfuncs_t *dfunc = device->funcs;
Fix a pile of leaks and uninit errors Still "some" more to go: a pile to do with transforms and temporary entities, and a nasty one with host_cbuf. There's also all the static block-alloc lists :/
2021-03-21 10:56:17 +00:00
memsuper_t *memsuper = new_memsuper ();
[vulkan] Rework pipeline parsing for better reuse It's not entirely there yet, but the basics are working. Work is still needed for avoiding duplication of objects (different threads will have different contexts and thus different tables, so necessary per-thread duplication should not become a problem) and general access to arbitrary fields (mostly just parsing the strings)
2021-02-04 08:03:49 +00:00
VkSamplerCreateInfo cInfo = {};
Fix a pile of leaks and uninit errors Still "some" more to go: a pile to do with transforms and temporary entities, and a nasty one with host_cbuf. There's also all the static block-alloc lists :/
2021-03-21 10:56:17 +00:00
if (!parse_object (ctx, memsuper, plist, parse_VkSamplerCreateInfo, &cInfo,
[vulkan] Start moving towards a deferred renderer After getting lights even vaguely working for alias models, I realized that it just wasn't going to be feasible to do nice lighting with forward rendering. This gets the bulk of the work done for deferred rendering, but still need to sort out the shaders before any real testing can be done.
2021-02-14 02:35:06 +00:00
properties)) {
Fix a pile of leaks and uninit errors Still "some" more to go: a pile to do with transforms and temporary entities, and a nasty one with host_cbuf. There's also all the static block-alloc lists :/
2021-03-21 10:56:17 +00:00
delete_memsuper (memsuper);
[vulkan] Rework pipeline parsing for better reuse It's not entirely there yet, but the basics are working. Work is still needed for avoiding duplication of objects (different threads will have different contexts and thus different tables, so necessary per-thread duplication should not become a problem) and general access to arbitrary fields (mostly just parsing the strings)
2021-02-04 08:03:49 +00:00
return 0;
}
VkSampler sampler;
[vulkan] Add a debug stack to the vulkan instance The stack is arbitrary strings that the validation layer debug callback prints in reverse order after each message. This makes it easy to work out what nodes in a pipeline/render pass plist are causing validation errors. Still have to narrow down the actual line, but the messages seem to help with that. Putting qfvPushDebug/qfvPopDebug around other calls to vulkan should help out a lot, tool. As a bonus, the stack is printed before debug_breakpoint is called, so it's immediately visible in gdb.
2021-11-30 03:24:45 +00:00
qfvPushDebug (ctx, va (ctx->va_ctx, "QFV_ParseSampler: %d", PL_Line (plist)));
[vulkan] Rework pipeline parsing for better reuse It's not entirely there yet, but the basics are working. Work is still needed for avoiding duplication of objects (different threads will have different contexts and thus different tables, so necessary per-thread duplication should not become a problem) and general access to arbitrary fields (mostly just parsing the strings)
2021-02-04 08:03:49 +00:00
dfunc->vkCreateSampler (device->dev, &cInfo, 0, &sampler);
[vulkan] Add a debug stack to the vulkan instance The stack is arbitrary strings that the validation layer debug callback prints in reverse order after each message. This makes it easy to work out what nodes in a pipeline/render pass plist are causing validation errors. Still have to narrow down the actual line, but the messages seem to help with that. Putting qfvPushDebug/qfvPopDebug around other calls to vulkan should help out a lot, tool. As a bonus, the stack is printed before debug_breakpoint is called, so it's immediately visible in gdb.
2021-11-30 03:24:45 +00:00
qfvPopDebug (ctx);
[vulkan] Rework pipeline parsing for better reuse It's not entirely there yet, but the basics are working. Work is still needed for avoiding duplication of objects (different threads will have different contexts and thus different tables, so necessary per-thread duplication should not become a problem) and general access to arbitrary fields (mostly just parsing the strings)
2021-02-04 08:03:49 +00:00
Fix a pile of leaks and uninit errors Still "some" more to go: a pile to do with transforms and temporary entities, and a nasty one with host_cbuf. There's also all the static block-alloc lists :/
2021-03-21 10:56:17 +00:00
delete_memsuper (memsuper);
[vulkan] Rework pipeline parsing for better reuse It's not entirely there yet, but the basics are working. Work is still needed for avoiding duplication of objects (different threads will have different contexts and thus different tables, so necessary per-thread duplication should not become a problem) and general access to arbitrary fields (mostly just parsing the strings)
2021-02-04 08:03:49 +00:00
return sampler;
}
[vulkan] Start moving towards a deferred renderer After getting lights even vaguely working for alias models, I realized that it just wasn't going to be feasible to do nice lighting with forward rendering. This gets the bulk of the work done for deferred rendering, but still need to sort out the shaders before any real testing can be done.
2021-02-14 02:35:06 +00:00
VkImage
QFV_ParseImage (vulkan_ctx_t *ctx, plitem_t *plist, plitem_t *properties)
{
qfv_device_t *device = ctx->device;
qfv_devfuncs_t *dfunc = device->funcs;
Fix a pile of leaks and uninit errors Still "some" more to go: a pile to do with transforms and temporary entities, and a nasty one with host_cbuf. There's also all the static block-alloc lists :/
2021-03-21 10:56:17 +00:00
memsuper_t *memsuper = new_memsuper ();
[vulkan] Start moving towards a deferred renderer After getting lights even vaguely working for alias models, I realized that it just wasn't going to be feasible to do nice lighting with forward rendering. This gets the bulk of the work done for deferred rendering, but still need to sort out the shaders before any real testing can be done.
2021-02-14 02:35:06 +00:00
VkImageCreateInfo cInfo = {};
Fix a pile of leaks and uninit errors Still "some" more to go: a pile to do with transforms and temporary entities, and a nasty one with host_cbuf. There's also all the static block-alloc lists :/
2021-03-21 10:56:17 +00:00
if (!parse_object (ctx, memsuper, plist, parse_VkImageCreateInfo, &cInfo,
[vulkan] Start moving towards a deferred renderer After getting lights even vaguely working for alias models, I realized that it just wasn't going to be feasible to do nice lighting with forward rendering. This gets the bulk of the work done for deferred rendering, but still need to sort out the shaders before any real testing can be done.
2021-02-14 02:35:06 +00:00
properties)) {
Fix a pile of leaks and uninit errors Still "some" more to go: a pile to do with transforms and temporary entities, and a nasty one with host_cbuf. There's also all the static block-alloc lists :/
2021-03-21 10:56:17 +00:00
delete_memsuper (memsuper);
[vulkan] Start moving towards a deferred renderer After getting lights even vaguely working for alias models, I realized that it just wasn't going to be feasible to do nice lighting with forward rendering. This gets the bulk of the work done for deferred rendering, but still need to sort out the shaders before any real testing can be done.
2021-02-14 02:35:06 +00:00
return 0;
}
VkImage image;
[vulkan] Add a debug stack to the vulkan instance The stack is arbitrary strings that the validation layer debug callback prints in reverse order after each message. This makes it easy to work out what nodes in a pipeline/render pass plist are causing validation errors. Still have to narrow down the actual line, but the messages seem to help with that. Putting qfvPushDebug/qfvPopDebug around other calls to vulkan should help out a lot, tool. As a bonus, the stack is printed before debug_breakpoint is called, so it's immediately visible in gdb.
2021-11-30 03:24:45 +00:00
qfvPushDebug (ctx, va (ctx->va_ctx, "QFV_ParseImage: %d", PL_Line (plist)));
[vulkan] Start moving towards a deferred renderer After getting lights even vaguely working for alias models, I realized that it just wasn't going to be feasible to do nice lighting with forward rendering. This gets the bulk of the work done for deferred rendering, but still need to sort out the shaders before any real testing can be done.
2021-02-14 02:35:06 +00:00
dfunc->vkCreateImage (device->dev, &cInfo, 0, &image);
[vulkan] Add a debug stack to the vulkan instance The stack is arbitrary strings that the validation layer debug callback prints in reverse order after each message. This makes it easy to work out what nodes in a pipeline/render pass plist are causing validation errors. Still have to narrow down the actual line, but the messages seem to help with that. Putting qfvPushDebug/qfvPopDebug around other calls to vulkan should help out a lot, tool. As a bonus, the stack is printed before debug_breakpoint is called, so it's immediately visible in gdb.
2021-11-30 03:24:45 +00:00
qfvPopDebug (ctx);
[vulkan] Start moving towards a deferred renderer After getting lights even vaguely working for alias models, I realized that it just wasn't going to be feasible to do nice lighting with forward rendering. This gets the bulk of the work done for deferred rendering, but still need to sort out the shaders before any real testing can be done.
2021-02-14 02:35:06 +00:00
Fix a pile of leaks and uninit errors Still "some" more to go: a pile to do with transforms and temporary entities, and a nasty one with host_cbuf. There's also all the static block-alloc lists :/
2021-03-21 10:56:17 +00:00
delete_memsuper (memsuper);
[vulkan] Start moving towards a deferred renderer After getting lights even vaguely working for alias models, I realized that it just wasn't going to be feasible to do nice lighting with forward rendering. This gets the bulk of the work done for deferred rendering, but still need to sort out the shaders before any real testing can be done.
2021-02-14 02:35:06 +00:00
return image;
}
VkImageView
QFV_ParseImageView (vulkan_ctx_t *ctx, plitem_t *plist, plitem_t *properties)
{
qfv_device_t *device = ctx->device;
qfv_devfuncs_t *dfunc = device->funcs;
Fix a pile of leaks and uninit errors Still "some" more to go: a pile to do with transforms and temporary entities, and a nasty one with host_cbuf. There's also all the static block-alloc lists :/
2021-03-21 10:56:17 +00:00
memsuper_t *memsuper = new_memsuper ();
[vulkan] Start moving towards a deferred renderer After getting lights even vaguely working for alias models, I realized that it just wasn't going to be feasible to do nice lighting with forward rendering. This gets the bulk of the work done for deferred rendering, but still need to sort out the shaders before any real testing can be done.
2021-02-14 02:35:06 +00:00
VkImageViewCreateInfo cInfo = {};
Fix a pile of leaks and uninit errors Still "some" more to go: a pile to do with transforms and temporary entities, and a nasty one with host_cbuf. There's also all the static block-alloc lists :/
2021-03-21 10:56:17 +00:00
if (!parse_object (ctx, memsuper, plist, parse_VkImageViewCreateInfo,
&cInfo, properties)) {
delete_memsuper (memsuper);
[vulkan] Start moving towards a deferred renderer After getting lights even vaguely working for alias models, I realized that it just wasn't going to be feasible to do nice lighting with forward rendering. This gets the bulk of the work done for deferred rendering, but still need to sort out the shaders before any real testing can be done.
2021-02-14 02:35:06 +00:00
return 0;
}
VkImageView imageView;
[vulkan] Add a debug stack to the vulkan instance The stack is arbitrary strings that the validation layer debug callback prints in reverse order after each message. This makes it easy to work out what nodes in a pipeline/render pass plist are causing validation errors. Still have to narrow down the actual line, but the messages seem to help with that. Putting qfvPushDebug/qfvPopDebug around other calls to vulkan should help out a lot, tool. As a bonus, the stack is printed before debug_breakpoint is called, so it's immediately visible in gdb.
2021-11-30 03:24:45 +00:00
qfvPushDebug (ctx, va (ctx->va_ctx, "QFV_ParseImageView: %d", PL_Line (plist)));
[vulkan] Start moving towards a deferred renderer After getting lights even vaguely working for alias models, I realized that it just wasn't going to be feasible to do nice lighting with forward rendering. This gets the bulk of the work done for deferred rendering, but still need to sort out the shaders before any real testing can be done.
2021-02-14 02:35:06 +00:00
dfunc->vkCreateImageView (device->dev, &cInfo, 0, &imageView);
[vulkan] Add a debug stack to the vulkan instance The stack is arbitrary strings that the validation layer debug callback prints in reverse order after each message. This makes it easy to work out what nodes in a pipeline/render pass plist are causing validation errors. Still have to narrow down the actual line, but the messages seem to help with that. Putting qfvPushDebug/qfvPopDebug around other calls to vulkan should help out a lot, tool. As a bonus, the stack is printed before debug_breakpoint is called, so it's immediately visible in gdb.
2021-11-30 03:24:45 +00:00
qfvPopDebug (ctx);
[vulkan] Start moving towards a deferred renderer After getting lights even vaguely working for alias models, I realized that it just wasn't going to be feasible to do nice lighting with forward rendering. This gets the bulk of the work done for deferred rendering, but still need to sort out the shaders before any real testing can be done.
2021-02-14 02:35:06 +00:00
Fix a pile of leaks and uninit errors Still "some" more to go: a pile to do with transforms and temporary entities, and a nasty one with host_cbuf. There's also all the static block-alloc lists :/
2021-03-21 10:56:17 +00:00
delete_memsuper (memsuper);
[vulkan] Start moving towards a deferred renderer After getting lights even vaguely working for alias models, I realized that it just wasn't going to be feasible to do nice lighting with forward rendering. This gets the bulk of the work done for deferred rendering, but still need to sort out the shaders before any real testing can be done.
2021-02-14 02:35:06 +00:00
return imageView;
}
typedef struct {
uint32_t count;
VkImageCreateInfo *info;
} imagecreate_t;
typedef struct {
uint32_t count;
VkImageViewCreateInfo *info;
} imageviewcreate_t;
static plelement_t qfv_imagecreate_dict = {
QFDictionary,
sizeof (VkImageCreateInfo),
Fix a pile of leaks and uninit errors Still "some" more to go: a pile to do with transforms and temporary entities, and a nasty one with host_cbuf. There's also all the static block-alloc lists :/
2021-03-21 10:56:17 +00:00
vkparse_alloc,
[vulkan] Start moving towards a deferred renderer After getting lights even vaguely working for alias models, I realized that it just wasn't going to be feasible to do nice lighting with forward rendering. This gets the bulk of the work done for deferred rendering, but still need to sort out the shaders before any real testing can be done.
2021-02-14 02:35:06 +00:00
parse_VkImageCreateInfo,
};
static plelement_t qfv_imageviewcreate_dict = {
QFDictionary,
sizeof (VkImageViewCreateInfo),
Fix a pile of leaks and uninit errors Still "some" more to go: a pile to do with transforms and temporary entities, and a nasty one with host_cbuf. There's also all the static block-alloc lists :/
2021-03-21 10:56:17 +00:00
vkparse_alloc,
[vulkan] Start moving towards a deferred renderer After getting lights even vaguely working for alias models, I realized that it just wasn't going to be feasible to do nice lighting with forward rendering. This gets the bulk of the work done for deferred rendering, but still need to sort out the shaders before any real testing can be done.
2021-02-14 02:35:06 +00:00
parse_VkImageViewCreateInfo,
};
static int
parse_imagecreate_dict (const plfield_t *field, const plitem_t *item,
void *data, plitem_t *messages, void *context)
{
plfield_t f = { "images", 0, QFArray, parse_array,
&qfv_imagecreate_dict };
typedef struct arr_s DARRAY_TYPE(byte) arr_t;
arr_t *arr = 0;
int ret;
if ((ret = PL_ParseLabeledArray (&f, item, &arr, messages, context))) {
imagecreate_t *imagecreate = data;
imagecreate->count = arr->size;
imagecreate->info = (VkImageCreateInfo *) arr->a;
}
return ret;
}
static int
parse_imageviewcreate_dict (const plfield_t *field, const plitem_t *item,
void *data, plitem_t *messages, void *context)
{
plfield_t f = { "images", 0, QFArray, parse_array,
&qfv_imageviewcreate_dict };
typedef struct arr_s DARRAY_TYPE(byte) arr_t;
arr_t *arr = 0;
int ret;
if ((ret = PL_ParseLabeledArray (&f, item, &arr, messages, context))) {
imageviewcreate_t *imageviewcreate = data;
imageviewcreate->count = arr->size;
imageviewcreate->info = (VkImageViewCreateInfo *) arr->a;
} else {
//FIXME leaky boat when succeeds
if (arr) {
free (arr);
}
}
return ret;
}
qfv_imageset_t *
QFV_ParseImageSet (vulkan_ctx_t *ctx, plitem_t *item, plitem_t *properties)
{
[vulkan] Make script support objects more private This will help keep changes to the scripting system localized once things are further cleaned up.
2022-11-24 14:44:07 +00:00
scriptctx_t *sctx = ctx->script_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
qfv_device_t *device = ctx->device;
qfv_devfuncs_t *dfunc = device->funcs;
Fix a pile of leaks and uninit errors Still "some" more to go: a pile to do with transforms and temporary entities, and a nasty one with host_cbuf. There's also all the static block-alloc lists :/
2021-03-21 10:56:17 +00:00
memsuper_t *memsuper = new_memsuper ();
[vulkan] Start moving towards a deferred renderer After getting lights even vaguely working for alias models, I realized that it just wasn't going to be feasible to do nice lighting with forward rendering. This gets the bulk of the work done for deferred rendering, but still need to sort out the shaders before any real testing can be done.
2021-02-14 02:35:06 +00:00
imagecreate_t create = {};
pltype_t type = PL_Type (item);
if (type == QFDictionary) {
Fix a pile of leaks and uninit errors Still "some" more to go: a pile to do with transforms and temporary entities, and a nasty one with host_cbuf. There's also all the static block-alloc lists :/
2021-03-21 10:56:17 +00:00
if (!parse_object (ctx, memsuper, item, parse_imagecreate_dict,
&create, properties)) {
delete_memsuper (memsuper);
[vulkan] Start moving towards a deferred renderer After getting lights even vaguely working for alias models, I realized that it just wasn't going to be feasible to do nice lighting with forward rendering. This gets the bulk of the work done for deferred rendering, but still need to sort out the shaders before any real testing can be done.
2021-02-14 02:35:06 +00:00
return 0;
}
} else {
[util] Make developer flag names easier to manage They're now an enum, and the flag part of the name is all lowercase, but now the flag definitions and names list will never get out of sync.
2021-03-29 10:58:00 +00:00
Sys_MaskPrintf (SYS_vulkan_parse, "Neither array nor dictionary: %d\n",
[vulkan] Suppress all the debug output silence is golden
2021-03-23 04:04:22 +00:00
PL_Line (item));
Fix a pile of leaks and uninit errors Still "some" more to go: a pile to do with transforms and temporary entities, and a nasty one with host_cbuf. There's also all the static block-alloc lists :/
2021-03-21 10:56:17 +00:00
delete_memsuper (memsuper);
[vulkan] Start moving towards a deferred renderer After getting lights even vaguely working for alias models, I realized that it just wasn't going to be feasible to do nice lighting with forward rendering. This gets the bulk of the work done for deferred rendering, but still need to sort out the shaders before any real testing can be done.
2021-02-14 02:35:06 +00:00
return 0;
}
__auto_type set = QFV_AllocImages (create.count, malloc);
for (uint32_t i = 0; i < create.count; i++) {
[vulkan] Add a debug stack to the vulkan instance The stack is arbitrary strings that the validation layer debug callback prints in reverse order after each message. This makes it easy to work out what nodes in a pipeline/render pass plist are causing validation errors. Still have to narrow down the actual line, but the messages seem to help with that. Putting qfvPushDebug/qfvPopDebug around other calls to vulkan should help out a lot, tool. As a bonus, the stack is printed before debug_breakpoint is called, so it's immediately visible in gdb.
2021-11-30 03:24:45 +00:00
qfvPushDebug (ctx, va (ctx->va_ctx, "QFV_ParseImageSet: %d", PL_Line (item)));
[vulkan] Start moving towards a deferred renderer After getting lights even vaguely working for alias models, I realized that it just wasn't going to be feasible to do nice lighting with forward rendering. This gets the bulk of the work done for deferred rendering, but still need to sort out the shaders before any real testing can be done.
2021-02-14 02:35:06 +00:00
dfunc->vkCreateImage (device->dev, &create.info[i], 0, &set->a[i]);
const char *name = PL_KeyAtIndex (item, i);
[vulkan] Implement lighting and compose passes Lighting doesn't actually do lights yet, but it's producing pixels. Translucent seems to be working (2d draw uses it), and compose seems to be working.
2021-02-24 10:58:31 +00:00
QFV_duSetObjectName (device, VK_OBJECT_TYPE_IMAGE, set->a[i],
va (ctx->va_ctx, "image:%s", name));
[vulkan] Add a debug stack to the vulkan instance The stack is arbitrary strings that the validation layer debug callback prints in reverse order after each message. This makes it easy to work out what nodes in a pipeline/render pass plist are causing validation errors. Still have to narrow down the actual line, but the messages seem to help with that. Putting qfvPushDebug/qfvPopDebug around other calls to vulkan should help out a lot, tool. As a bonus, the stack is printed before debug_breakpoint is called, so it's immediately visible in gdb.
2021-11-30 03:24:45 +00:00
qfvPopDebug (ctx);
[vulkan] Clean up misuse of va for vulkan handles The built up "path" name of the handle resource was not always surviving the intervening call to cexpr_eval_string (in particular, when other handles were created in the process of creating a handle). Rather than simply increase the number of va buffers (where would it end?), just regenerate the path when adding the new handle. It's probably quick enough, and the code is not usually not on a critical path.
2021-04-22 10:47:42 +00:00
name = resource_path (ctx, "images", name);
[vulkan] Make script support objects more private This will help keep changes to the scripting system localized once things are further cleaned up.
2022-11-24 14:44:07 +00:00
QFV_AddHandle (sctx->images, name, (uint64_t) set->a[i]);
[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 set;
}
qfv_imageviewset_t *
QFV_ParseImageViewSet (vulkan_ctx_t *ctx, plitem_t *item,
plitem_t *properties)
{
[vulkan] Make script support objects more private This will help keep changes to the scripting system localized once things are further cleaned up.
2022-11-24 14:44:07 +00:00
scriptctx_t *sctx = ctx->script_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
qfv_device_t *device = ctx->device;
qfv_devfuncs_t *dfunc = device->funcs;
Fix a pile of leaks and uninit errors Still "some" more to go: a pile to do with transforms and temporary entities, and a nasty one with host_cbuf. There's also all the static block-alloc lists :/
2021-03-21 10:56:17 +00:00
memsuper_t *memsuper = new_memsuper ();
[vulkan] Start moving towards a deferred renderer After getting lights even vaguely working for alias models, I realized that it just wasn't going to be feasible to do nice lighting with forward rendering. This gets the bulk of the work done for deferred rendering, but still need to sort out the shaders before any real testing can be done.
2021-02-14 02:35:06 +00:00
imageviewcreate_t create = {};
pltype_t type = PL_Type (item);
if (type == QFDictionary) {
Fix a pile of leaks and uninit errors Still "some" more to go: a pile to do with transforms and temporary entities, and a nasty one with host_cbuf. There's also all the static block-alloc lists :/
2021-03-21 10:56:17 +00:00
if (!parse_object (ctx, memsuper, item, parse_imageviewcreate_dict,
&create, properties)) {
delete_memsuper (memsuper);
[vulkan] Start moving towards a deferred renderer After getting lights even vaguely working for alias models, I realized that it just wasn't going to be feasible to do nice lighting with forward rendering. This gets the bulk of the work done for deferred rendering, but still need to sort out the shaders before any real testing can be done.
2021-02-14 02:35:06 +00:00
return 0;
}
} else {
Sys_Printf ("Neither array nor dictionary: %d\n", PL_Line (item));
Fix a pile of leaks and uninit errors Still "some" more to go: a pile to do with transforms and temporary entities, and a nasty one with host_cbuf. There's also all the static block-alloc lists :/
2021-03-21 10:56:17 +00:00
delete_memsuper (memsuper);
[vulkan] Start moving towards a deferred renderer After getting lights even vaguely working for alias models, I realized that it just wasn't going to be feasible to do nice lighting with forward rendering. This gets the bulk of the work done for deferred rendering, but still need to sort out the shaders before any real testing can be done.
2021-02-14 02:35:06 +00:00
return 0;
}
__auto_type set = QFV_AllocImageViews (create.count, malloc);
for (uint32_t i = 0; i < create.count; i++) {
[vulkan] Add a debug stack to the vulkan instance The stack is arbitrary strings that the validation layer debug callback prints in reverse order after each message. This makes it easy to work out what nodes in a pipeline/render pass plist are causing validation errors. Still have to narrow down the actual line, but the messages seem to help with that. Putting qfvPushDebug/qfvPopDebug around other calls to vulkan should help out a lot, tool. As a bonus, the stack is printed before debug_breakpoint is called, so it's immediately visible in gdb.
2021-11-30 03:24:45 +00:00
qfvPushDebug (ctx, va (ctx->va_ctx, "QFV_ParseImageViewSet: %d", PL_Line (item)));
[vulkan] Start moving towards a deferred renderer After getting lights even vaguely working for alias models, I realized that it just wasn't going to be feasible to do nice lighting with forward rendering. This gets the bulk of the work done for deferred rendering, but still need to sort out the shaders before any real testing can be done.
2021-02-14 02:35:06 +00:00
dfunc->vkCreateImageView (device->dev, &create.info[i], 0, &set->a[i]);
[vulkan] Add a debug stack to the vulkan instance The stack is arbitrary strings that the validation layer debug callback prints in reverse order after each message. This makes it easy to work out what nodes in a pipeline/render pass plist are causing validation errors. Still have to narrow down the actual line, but the messages seem to help with that. Putting qfvPushDebug/qfvPopDebug around other calls to vulkan should help out a lot, tool. As a bonus, the stack is printed before debug_breakpoint is called, so it's immediately visible in gdb.
2021-11-30 03:24:45 +00:00
qfvPopDebug (ctx);
[vulkan] Start moving towards a deferred renderer After getting lights even vaguely working for alias models, I realized that it just wasn't going to be feasible to do nice lighting with forward rendering. This gets the bulk of the work done for deferred rendering, but still need to sort out the shaders before any real testing can be done.
2021-02-14 02:35:06 +00:00
const char *name = PL_KeyAtIndex (item, i);
[vulkan] Clean up misuse of va for vulkan handles The built up "path" name of the handle resource was not always surviving the intervening call to cexpr_eval_string (in particular, when other handles were created in the process of creating a handle). Rather than simply increase the number of va buffers (where would it end?), just regenerate the path when adding the new handle. It's probably quick enough, and the code is not usually not on a critical path.
2021-04-22 10:47:42 +00:00
name = resource_path (ctx, "imageViews", name);
[vulkan] Make script support objects more private This will help keep changes to the scripting system localized once things are further cleaned up.
2022-11-24 14:44:07 +00:00
QFV_AddHandle (sctx->imageViews, name, (uint64_t) set->a[i]);
[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 set;
}
VkFramebuffer
QFV_ParseFramebuffer (vulkan_ctx_t *ctx, plitem_t *plist, plitem_t *properties)
{
qfv_device_t *device = ctx->device;
qfv_devfuncs_t *dfunc = device->funcs;
Fix a pile of leaks and uninit errors Still "some" more to go: a pile to do with transforms and temporary entities, and a nasty one with host_cbuf. There's also all the static block-alloc lists :/
2021-03-21 10:56:17 +00:00
memsuper_t *memsuper = new_memsuper ();
[vulkan] Start moving towards a deferred renderer After getting lights even vaguely working for alias models, I realized that it just wasn't going to be feasible to do nice lighting with forward rendering. This gets the bulk of the work done for deferred rendering, but still need to sort out the shaders before any real testing can be done.
2021-02-14 02:35:06 +00:00
VkFramebufferCreateInfo cInfo = {};
Fix a pile of leaks and uninit errors Still "some" more to go: a pile to do with transforms and temporary entities, and a nasty one with host_cbuf. There's also all the static block-alloc lists :/
2021-03-21 10:56:17 +00:00
if (!parse_object (ctx, memsuper, plist, parse_VkFramebufferCreateInfo,
&cInfo, properties)) {
delete_memsuper (memsuper);
[vulkan] Start moving towards a deferred renderer After getting lights even vaguely working for alias models, I realized that it just wasn't going to be feasible to do nice lighting with forward rendering. This gets the bulk of the work done for deferred rendering, but still need to sort out the shaders before any real testing can be done.
2021-02-14 02:35:06 +00:00
return 0;
}
VkFramebuffer framebuffer;
[vulkan] Add a debug stack to the vulkan instance The stack is arbitrary strings that the validation layer debug callback prints in reverse order after each message. This makes it easy to work out what nodes in a pipeline/render pass plist are causing validation errors. Still have to narrow down the actual line, but the messages seem to help with that. Putting qfvPushDebug/qfvPopDebug around other calls to vulkan should help out a lot, tool. As a bonus, the stack is printed before debug_breakpoint is called, so it's immediately visible in gdb.
2021-11-30 03:24:45 +00:00
qfvPushDebug (ctx, va (ctx->va_ctx, "QFV_ParseFramebuffer: %d", PL_Line (plist)));
[vulkan] Start moving towards a deferred renderer After getting lights even vaguely working for alias models, I realized that it just wasn't going to be feasible to do nice lighting with forward rendering. This gets the bulk of the work done for deferred rendering, but still need to sort out the shaders before any real testing can be done.
2021-02-14 02:35:06 +00:00
dfunc->vkCreateFramebuffer (device->dev, &cInfo, 0, &framebuffer);
[vulkan] Add a debug stack to the vulkan instance The stack is arbitrary strings that the validation layer debug callback prints in reverse order after each message. This makes it easy to work out what nodes in a pipeline/render pass plist are causing validation errors. Still have to narrow down the actual line, but the messages seem to help with that. Putting qfvPushDebug/qfvPopDebug around other calls to vulkan should help out a lot, tool. As a bonus, the stack is printed before debug_breakpoint is called, so it's immediately visible in gdb.
2021-11-30 03:24:45 +00:00
qfvPopDebug (ctx);
[vulkan] Fix some 32-bit compatibility issues mostly dealing with vulkan's handles always being 64-bit, but pointers being either 32 or 64.
2021-04-01 23:48:11 +00:00
Sys_MaskPrintf (SYS_vulkan_parse, "framebuffer, renderPass: %#zx, %#zx\n",
(size_t) framebuffer, (size_t) cInfo.renderPass);
[vulkan] Start moving towards a deferred renderer After getting lights even vaguely working for alias models, I realized that it just wasn't going to be feasible to do nice lighting with forward rendering. This gets the bulk of the work done for deferred rendering, but still need to sort out the shaders before any real testing can be done.
2021-02-14 02:35:06 +00:00
Fix a pile of leaks and uninit errors Still "some" more to go: a pile to do with transforms and temporary entities, and a nasty one with host_cbuf. There's also all the static block-alloc lists :/
2021-03-21 10:56:17 +00:00
delete_memsuper (memsuper);
[vulkan] Start moving towards a deferred renderer After getting lights even vaguely working for alias models, I realized that it just wasn't going to be feasible to do nice lighting with forward rendering. This gets the bulk of the work done for deferred rendering, but still need to sort out the shaders before any real testing can be done.
2021-02-14 02:35:06 +00:00
return framebuffer;
}
[vulkan] Parse clear values And get the render pass working in general. Note that this is only the render pass and frame buffers: actual commands still have problems.
2021-02-23 05:37:48 +00:00
static int
parse_clearvalueset (const plfield_t *field, const plitem_t *item, void *data,
plitem_t *messages, void *context)
{
plelement_t element = {
QFDictionary,
sizeof (VkClearValue),
Fix a pile of leaks and uninit errors Still "some" more to go: a pile to do with transforms and temporary entities, and a nasty one with host_cbuf. There's also all the static block-alloc lists :/
2021-03-21 10:56:17 +00:00
vkparse_alloc,
[vulkan] Parse clear values And get the render pass working in general. Note that this is only the render pass and frame buffers: actual commands still have problems.
2021-02-23 05:37:48 +00:00
parse_VkClearValue,
0,
};
plfield_t f = { 0, 0, 0, 0, &element };
Fix a pile of leaks and uninit errors Still "some" more to go: a pile to do with transforms and temporary entities, and a nasty one with host_cbuf. There's also all the static block-alloc lists :/
2021-03-21 10:56:17 +00:00
if (!PL_ParseArray (&f, item, data, messages, context)) {
[vulkan] Parse clear values And get the render pass working in general. Note that this is only the render pass and frame buffers: actual commands still have problems.
2021-02-23 05:37:48 +00:00
return 0;
}
return 1;
}
[vulkan] Support multiple render passes Multiple render passes are needed for supporting shadow mapping, and this is a huge step towards breaking the Vulkan render free of Quake, and hopefully will lead the way for breaking the GL renderers free as well.
2021-12-02 12:58:29 +00:00
clearvalueset_t *
[vulkan] Parse clear values And get the render pass working in general. Note that this is only the render pass and frame buffers: actual commands still have problems.
2021-02-23 05:37:48 +00:00
QFV_ParseClearValues (vulkan_ctx_t *ctx, plitem_t *plist, plitem_t *properties)
{
[vulkan] Support multiple render passes Multiple render passes are needed for supporting shadow mapping, and this is a huge step towards breaking the Vulkan render free of Quake, and hopefully will lead the way for breaking the GL renderers free as well.
2021-12-02 12:58:29 +00:00
clearvalueset_t *cv = 0;
Fix a pile of leaks and uninit errors Still "some" more to go: a pile to do with transforms and temporary entities, and a nasty one with host_cbuf. There's also all the static block-alloc lists :/
2021-03-21 10:56:17 +00:00
memsuper_t *memsuper = new_memsuper ();
clearvalueset_t *clearValues = 0;
if (parse_object (ctx, memsuper, plist, parse_clearvalueset, &clearValues,
properties)) {
[vulkan] Support multiple render passes Multiple render passes are needed for supporting shadow mapping, and this is a huge step towards breaking the Vulkan render free of Quake, and hopefully will lead the way for breaking the GL renderers free as well.
2021-12-02 12:58:29 +00:00
cv = DARRAY_ALLOCFIXED (clearvalueset_t, clearValues->size, malloc);
memcpy (cv->a, clearValues->a, cv->size * sizeof (cv->a[0]));
[vulkan] Parse clear values And get the render pass working in general. Note that this is only the render pass and frame buffers: actual commands still have problems.
2021-02-23 05:37:48 +00:00
}
Fix a pile of leaks and uninit errors Still "some" more to go: a pile to do with transforms and temporary entities, and a nasty one with host_cbuf. There's also all the static block-alloc lists :/
2021-03-21 10:56:17 +00:00
delete_memsuper (memsuper);
[vulkan] Support multiple render passes Multiple render passes are needed for supporting shadow mapping, and this is a huge step towards breaking the Vulkan render free of Quake, and hopefully will lead the way for breaking the GL renderers free as well.
2021-12-02 12:58:29 +00:00
return cv;
[vulkan] Parse clear values And get the render pass working in general. Note that this is only the render pass and frame buffers: actual commands still have problems.
2021-02-23 05:37:48 +00:00
}
[vulkan] Make Vulkan_CreateRenderPass more generally useful It now lives in vulkan_renderpass.c and takes most of its parameters from plist configs (just the name (which is used to find the config), output spec, and draw function from C). Even the debug colors and names are taken from the config.
2022-05-30 06:58:22 +00:00
static int
parse_subpassset (const plfield_t *field, const plitem_t *item, void *data,
plitem_t *messages, void *context)
{
plelement_t element = {
QFDictionary,
sizeof (qfv_subpass_t),
vkparse_alloc,
parse_qfv_subpass_t,
0,
};
plfield_t f = { 0, 0, 0, 0, &element };
if (!PL_ParseArray (&f, item, data, messages, context)) {
return 0;
}
return 1;
}
qfv_subpassset_t *
QFV_ParseSubpasses (vulkan_ctx_t *ctx, plitem_t *plist, plitem_t *properties)
{
qfv_subpassset_t *sp = 0;
memsuper_t *memsuper = new_memsuper ();
qfv_subpassset_t *subpasses = 0;
if (parse_object (ctx, memsuper, plist, parse_subpassset, &subpasses,
properties)) {
sp = DARRAY_ALLOCFIXED (qfv_subpassset_t, subpasses->size, malloc);
memcpy (sp->a, subpasses->a, sp->size * sizeof (sp->a[0]));
// the name is in memsuper which is about to be freed
for (size_t i = 0; i < sp->size; i++) {
sp->a[i].name = strdup (sp->a[i].name);
}
}
delete_memsuper (memsuper);
return sp;
}
static int
parse_rgba (const plfield_t *field, const plitem_t *item, void *data,
plitem_t *messages, void *context)
{
return parse_RGBA (item, &data, messages, context);
}
int
QFV_ParseRGBA (vulkan_ctx_t *ctx, float *rgba, plitem_t *plist,
plitem_t *properties)
{
memsuper_t *memsuper = new_memsuper ();
int ret = 0;
vec4f_t color;
if (parse_object (ctx, memsuper, plist, parse_rgba, &color, properties)) {
memcpy (rgba, &color, sizeof (color));
ret = 1;
}
delete_memsuper (memsuper);
return ret;
}
[vulkan] Make script support objects more private This will help keep changes to the scripting system localized once things are further cleaned up.
2022-11-24 14:44:07 +00:00
[vulkan] Support parsing qfv_output_t This will be needed by the revamped render pass code.
2022-11-26 13:22:22 +00:00
int
QFV_ParseOutput (vulkan_ctx_t *ctx, qfv_output_t *output, plitem_t *plist,
plitem_t *properties)
{
memsuper_t *memsuper = new_memsuper ();
int ret = 0;
qfv_output_t op = {};
if (parse_object (ctx, memsuper, plist, parse_qfv_output_t, &op,
properties)) {
memcpy (output, &op, sizeof (*output));
ret = 1;
}
delete_memsuper (memsuper);
return ret;
}
[vulkan] Make script support objects more private This will help keep changes to the scripting system localized once things are further cleaned up.
2022-11-24 14:44:07 +00:00
int vulkan_frame_count;
static cvar_t vulkan_frame_count_cvar = {
.name = "vulkan_frame_count",
.description =
"Number of frames to render in the background. More frames can "
"increase performance, but at the cost of latency. The default of 3 is"
" recommended.",
.default_value = "3",
.flags = CVAR_NONE,
.value = { .type = &cexpr_int, .value = &vulkan_frame_count },
};
int vulkan_presentation_mode;
static cvar_t vulkan_presentation_mode_cvar = {
.name = "vulkan_presentation_mode",
.description =
"desired presentation mode (may fall back to fifo).",
.default_value = "mailbox",
.flags = CVAR_NONE,
.value = {
.type = &VkPresentModeKHR_type,
.value = &vulkan_presentation_mode,
},
};
int msaaSamples;
static cvar_t msaaSamples_cvar = {
.name = "msaaSamples",
.description =
"desired MSAA sample size.",
.default_value = "VK_SAMPLE_COUNT_1_BIT",
.flags = CVAR_NONE,
.value = { .type = &VkSampleCountFlagBits_type, .value = &msaaSamples },
};
static exprenum_t validation_enum;
static exprtype_t validation_type = {
.name = "vulkan_use_validation",
.size = sizeof (int),
.binops = cexpr_flag_binops,
.unops = cexpr_flag_unops,
.data = &validation_enum,
.get_string = cexpr_flags_get_string,
};
static int validation_values[] = {
0,
VK_DEBUG_UTILS_MESSAGE_SEVERITY_FLAG_BITS_MAX_ENUM_EXT,
};
static exprsym_t validation_symbols[] = {
{"none", &validation_type, validation_values + 0},
{"all", &validation_type, validation_values + 1},
{}
};
static exprtab_t validation_symtab = {
validation_symbols,
};
static exprenum_t validation_enum = {
&validation_type,
&validation_symtab,
};
static cvar_t vulkan_use_validation_cvar = {
.name = "vulkan_use_validation",
.description =
"enable KRONOS Validation Layer if available (requires instance "
"restart).",
.default_value = "error|warning",
.flags = CVAR_NONE,
.value = { .type = &validation_type, .value = &vulkan_use_validation },
};
static void
vulkan_frame_count_f (void *data, const cvar_t *cvar)
{
if (vulkan_frame_count < 1) {
Sys_Printf ("Invalid frame count: %d. Setting to 1\n",
vulkan_frame_count);
vulkan_frame_count = 1;
}
}
void
Vulkan_Init_Cvars (void)
{
int num_syms = 0;
for (exprsym_t *sym = VkDebugUtilsMessageSeverityFlagBitsEXT_symbols;
sym->name; sym++, num_syms++) {
}
for (exprsym_t *sym = validation_symbols; sym->name; sym++, num_syms++) {
}
validation_symtab.symbols = calloc (num_syms + 1, sizeof (exprsym_t));
num_syms = 0;
for (exprsym_t *sym = VkDebugUtilsMessageSeverityFlagBitsEXT_symbols;
sym->name; sym++, num_syms++) {
validation_symtab.symbols[num_syms] = *sym;
validation_symtab.symbols[num_syms].type = &validation_type;
}
for (exprsym_t *sym = validation_symbols; sym->name; sym++, num_syms++) {
validation_symtab.symbols[num_syms] = *sym;
}
Cvar_Register (&vulkan_use_validation_cvar, 0, 0);
// FIXME implement fallback choices (instead of just fifo)
Cvar_Register (&vulkan_presentation_mode_cvar, 0, 0);
Cvar_Register (&vulkan_frame_count_cvar, vulkan_frame_count_f, 0);
Cvar_Register (&msaaSamples_cvar, 0, 0);
}
static exprsym_t builtin_plist_syms[] = {
{ .name = "quake_deferred",
.value = (void *)
#include "libs/video/renderer/vulkan/pl_quake_def.plc"
},
{ .name = "qf_output",
.value = (void *)
#include "libs/video/renderer/vulkan/pl_output.plc"
},
[vulkan] Implement most of the changes for cube rendering There are some missing parts from this commit as these are the fairly clean changes. Missing is building a separate set of pipelines for the new render pass (might be able to get away from that), OIT heads texture is flat rather than an array, view matrices aren't set up, and the fisheye renderer isn't hooked up to the output pass (code exists but is messy). However, with the missing parts included, testing shows things mostly working: the cube map is rendered correctly even though it's not displayed correctly (incorrect view). This has definitely proven to be a good test for Vulkan's multiview feature (very nice).
2023-01-23 02:14:06 +00:00
{ .name = "defcube",
.value = (void *)
#include "libs/video/renderer/vulkan/rp_defcube.plc"
},
[vulkan] Make script support objects more private This will help keep changes to the scripting system localized once things are further cleaned up.
2022-11-24 14:44:07 +00:00
{ .name = "deferred",
.value = (void *)
#include "libs/video/renderer/vulkan/rp_deferred.plc"
},
{ .name = "shadow",
.value = (void *)
#include "libs/video/renderer/vulkan/rp_shadow.plc"
},
{ .name = "forward",
.value = (void *)
#include "libs/video/renderer/vulkan/rp_forward.plc"
},
[vulkan] Attempt to load the render info spec It fails due to not supporting labeled arrays yet. I'm currently thinking about the design for vkgen.
2023-02-10 02:04:11 +00:00
{ .name = "main_def",
.value = (void *)
#include "libs/video/renderer/vulkan/rp_main_def.plc"
},
[vulkan] Make script support objects more private This will help keep changes to the scripting system localized once things are further cleaned up.
2022-11-24 14:44:07 +00:00
{ .name = "output",
.value = (void *)
#include "libs/video/renderer/vulkan/rp_output.plc"
},
{}
};
static plitem_t **builtin_plists;
static exprtab_t builtin_configs = { .symbols = builtin_plist_syms };
static void
build_configs (scriptctx_t *sctx)
{
int num_plists = 0;
for (exprsym_t *sym = builtin_plist_syms; sym->name; sym++) {
num_plists++;
}
builtin_plists = malloc (num_plists * sizeof (plitem_t *));
num_plists = 0;
for (exprsym_t *sym = builtin_plist_syms; sym->name; sym++) {
[vulkan] Use bare dictionaries for spec files Every time I created a new file from scratch, I always forgot the enclosing {}. Now I will probably include them by accident :P
2023-03-12 05:48:14 +00:00
plitem_t *item = PL_GetDictionary (sym->value, &sctx->hashctx);
[vulkan] Make script support objects more private This will help keep changes to the scripting system localized once things are further cleaned up.
2022-11-24 14:44:07 +00:00
if (!item) {
// Syntax errors in the compiled-in plists are unrecoverable
Sys_Error ("Error parsing plist for %s", sym->name);
}
builtin_plists[num_plists] = item;
sym->value = &builtin_plists[num_plists];
sym->type = &cexpr_plitem;
num_plists++;
}
exprctx_t ectx = { .hashctx = &sctx->hashctx };
cexpr_init_symtab (&builtin_configs, &ectx);
}
[vulkan] Fix some memory leaks And deal with a shutdown order issue causing cvars to crash on shutdown (due to the hash links being freed too early).
2023-03-05 09:19:54 +00:00
static void
delete_configs (void)
{
int num_plists = 0;
for (exprsym_t *sym = builtin_plist_syms; sym->name; sym++) {
[plist] Use reference counts for items This makes it much easier to share items between property lists (eg, targets and the main entity list in cl_light).
2023-03-12 06:17:28 +00:00
PL_Release (builtin_plists[num_plists]);
[vulkan] Fix some memory leaks And deal with a shutdown order issue causing cvars to crash on shutdown (due to the hash links being freed too early).
2023-03-05 09:19:54 +00:00
num_plists++;
}
free (builtin_plists);
}
[vulkan] Make script support objects more private This will help keep changes to the scripting system localized once things are further cleaned up.
2022-11-24 14:44:07 +00:00
static plitem_t *
qfv_load_pipeline (vulkan_ctx_t *ctx, const char *name)
{
scriptctx_t *sctx = ctx->script_context;
if (!sctx->pipelineDef) {
sctx->pipelineDef = Vulkan_GetConfig (ctx, "quake_deferred");
}
plitem_t *item = sctx->pipelineDef;
if (!item || !(item = PL_ObjectForKey (item, name))) {
Sys_Printf ("error loading %s\n", name);
} else {
Sys_MaskPrintf (SYS_vulkan_parse, "Found %s def\n", name);
}
return item;
}
plitem_t *
Vulkan_GetConfig (vulkan_ctx_t *ctx, const char *name)
{
scriptctx_t *sctx = ctx->script_context;
if (!builtin_configs.tab) {
build_configs (sctx);
}
plitem_t *config = 0;
exprval_t result = { .type = &cexpr_plitem, .value = &config };
exprctx_t ectx = {
.result = &result,
.symtab = &builtin_configs,
.memsuper = new_memsuper (),
.hashctx = &sctx->hashctx,
.messages = PL_NewArray (),
};
if (cexpr_eval_string (name, &ectx)) {
dstring_t *msg = dstring_newstr ();
for (int i = 0; i < PL_A_NumObjects (ectx.messages); i++) {
dasprintf (msg, "%s\n",
PL_String (PL_ObjectAtIndex (ectx.messages, i)));
}
Sys_Printf ("%s", msg->str);
dstring_delete (msg);
config = 0;
}
[plist] Use reference counts for items This makes it much easier to share items between property lists (eg, targets and the main entity list in cl_light).
2023-03-12 06:17:28 +00:00
PL_Release (ectx.messages);
[vulkan] Make script support objects more private This will help keep changes to the scripting system localized once things are further cleaned up.
2022-11-24 14:44:07 +00:00
delete_memsuper (ectx.memsuper);
return config;
}
void Vulkan_Script_Init (vulkan_ctx_t *ctx)
{
scriptctx_t *sctx = calloc (1, sizeof (scriptctx_t));
sctx->vctx = ctx;
ctx->script_context = sctx;
exprctx_t ectx = {};
enum_symtab = Hash_NewTable (61, enum_symtab_getkey, 0, 0, &sctx->hashctx);
parser_table = Hash_NewTable (61, parser_getkey, 0, 0, &sctx->hashctx);
[vulkan] Fix some memory leaks And deal with a shutdown order issue causing cvars to crash on shutdown (due to the hash links being freed too early).
2023-03-05 09:19:54 +00:00
//FIXME using the script context's hashctx causes the cvar system to access
//freed hash links due to shutdown order issues. The proper fix would be to
//create a symtabs shutdown (for thread safety), but this works for now.
ectx.hashctx = 0;//&sctx->hashctx;
[vulkan] Make script support objects more private This will help keep changes to the scripting system localized once things are further cleaned up.
2022-11-24 14:44:07 +00:00
vkgen_init_symtabs (&ectx);
cexpr_init_symtab (&qfv_output_t_symtab, &ectx);
cexpr_init_symtab (&vulkan_frameset_t_symtab, &ectx);
cexpr_init_symtab (&data_array_symtab, &ectx);
sctx->shaderModules = handlref_symtab (shaderModule_free, sctx);
sctx->setLayouts = handlref_symtab (setLayout_free, sctx);
sctx->pipelineLayouts = handlref_symtab (pipelineLayout_free, sctx);
sctx->descriptorPools = handlref_symtab (descriptorPool_free, sctx);
sctx->samplers = handlref_symtab (sampler_free, sctx);
sctx->images = handlref_symtab (image_free, sctx);
sctx->imageViews = handlref_symtab (imageView_free, sctx);
sctx->renderpasses = handlref_symtab (renderpass_free, sctx);
}
static void
clear_table (hashtab_t **table)
{
if (*table) {
hashtab_t *tab = *table;
*table = 0;
Hash_DelTable (tab);
}
}
void Vulkan_Script_Shutdown (vulkan_ctx_t *ctx)
{
scriptctx_t *sctx = ctx->script_context;
clear_table (&sctx->pipelineLayouts);
clear_table (&sctx->setLayouts);
clear_table (&sctx->shaderModules);
clear_table (&sctx->descriptorPools);
clear_table (&sctx->samplers);
[vulkan] Fix some memory leaks And deal with a shutdown order issue causing cvars to crash on shutdown (due to the hash links being freed too early).
2023-03-05 09:19:54 +00:00
delete_configs ();
Hash_DelContext (sctx->hashctx);
[vulkan] Make script support objects more private This will help keep changes to the scripting system localized once things are further cleaned up.
2022-11-24 14:44:07 +00:00
free (sctx);
}
void Vulkan_Script_SetOutput (vulkan_ctx_t *ctx, qfv_output_t *output)
{
scriptctx_t *sctx = ctx->script_context;
sctx->output = *output;
}
VkPipeline
Vulkan_CreateComputePipeline (vulkan_ctx_t *ctx, const char *name)
{
scriptctx_t *sctx = ctx->script_context;
plitem_t *item = qfv_load_pipeline (ctx, "pipelines");
if (!(item = PL_ObjectForKey (item, name))) {
Sys_Printf ("error loading pipeline %s\n", name);
return 0;
} else {
Sys_MaskPrintf (SYS_vulkan_parse, "Found pipeline def %s\n", name);
}
VkPipeline pipeline = QFV_ParseComputePipeline (ctx, item,
sctx->pipelineDef);
QFV_duSetObjectName (ctx->device, VK_OBJECT_TYPE_PIPELINE, pipeline,
va (ctx->va_ctx, "pipeline:%s", name));
return pipeline;
}
VkPipeline
Vulkan_CreateGraphicsPipeline (vulkan_ctx_t *ctx, const char *name)
{
scriptctx_t *sctx = ctx->script_context;
plitem_t *item = qfv_load_pipeline (ctx, "pipelines");
if (!(item = PL_ObjectForKey (item, name))) {
Sys_Printf ("error loading pipeline %s\n", name);
return 0;
} else {
Sys_MaskPrintf (SYS_vulkan_parse, "Found pipeline def %s\n", name);
}
VkPipeline pipeline = QFV_ParseGraphicsPipeline (ctx, item,
sctx->pipelineDef);
QFV_duSetObjectName (ctx->device, VK_OBJECT_TYPE_PIPELINE, pipeline,
va (ctx->va_ctx, "pipeline:%s", name));
return pipeline;
}
VkDescriptorPool
Vulkan_CreateDescriptorPool (vulkan_ctx_t *ctx, const char *name)
{
scriptctx_t *sctx = ctx->script_context;
hashtab_t *tab = sctx->descriptorPools;
const char *path;
path = va (ctx->va_ctx, "$"QFV_PROPERTIES".descriptorPools.%s", name);
__auto_type pool = (VkDescriptorPool) QFV_GetHandle (tab, path);
if (pool) {
return pool;
}
plitem_t *item = qfv_load_pipeline (ctx, "descriptorPools");
if (!(item = PL_ObjectForKey (item, name))) {
Sys_Printf ("error loading descriptor pool %s\n", name);
return 0;
} else {
Sys_MaskPrintf (SYS_vulkan_parse, "Found descriptor pool def %s\n",
name);
}
pool = QFV_ParseDescriptorPool (ctx, item, sctx->pipelineDef);
QFV_AddHandle (tab, path, (uint64_t) pool);
QFV_duSetObjectName (ctx->device, VK_OBJECT_TYPE_DESCRIPTOR_POOL, pool,
va (ctx->va_ctx, "descriptor_pool:%s", name));
return pool;
}
VkPipelineLayout
Vulkan_CreatePipelineLayout (vulkan_ctx_t *ctx, const char *name)
{
scriptctx_t *sctx = ctx->script_context;
hashtab_t *tab = sctx->pipelineLayouts;
const char *path;
path = va (ctx->va_ctx, "$"QFV_PROPERTIES".pipelineLayouts.%s", name);
__auto_type layout = (VkPipelineLayout) QFV_GetHandle (tab, path);
if (layout) {
return layout;
}
plitem_t *item = qfv_load_pipeline (ctx, "pipelineLayouts");
if (!(item = PL_ObjectForKey (item, name))) {
Sys_Printf ("error loading pipeline layout %s\n", name);
return 0;
} else {
Sys_MaskPrintf (SYS_vulkan_parse, "Found pipeline layout def %s\n",
name);
}
layout = QFV_ParsePipelineLayout (ctx, item, sctx->pipelineDef);
QFV_AddHandle (tab, path, (uint64_t) layout);
QFV_duSetObjectName (ctx->device, VK_OBJECT_TYPE_PIPELINE_LAYOUT, layout,
va (ctx->va_ctx, "pipeline_layout:%s", name));
return layout;
}
VkSampler
Vulkan_CreateSampler (vulkan_ctx_t *ctx, const char *name)
{
scriptctx_t *sctx = ctx->script_context;
hashtab_t *tab = sctx->samplers;
const char *path;
path = va (ctx->va_ctx, "$"QFV_PROPERTIES".samplers.%s", name);
__auto_type sampler = (VkSampler) QFV_GetHandle (tab, path);
if (sampler) {
return sampler;
}
plitem_t *item = qfv_load_pipeline (ctx, "samplers");
if (!(item = PL_ObjectForKey (item, name))) {
Sys_Printf ("error loading sampler %s\n", name);
return 0;
} else {
Sys_MaskPrintf (SYS_vulkan_parse, "Found sampler def %s\n", name);
}
sampler = QFV_ParseSampler (ctx, item, sctx->pipelineDef);
QFV_AddHandle (tab, path, (uint64_t) sampler);
QFV_duSetObjectName (ctx->device, VK_OBJECT_TYPE_SAMPLER, sampler,
va (ctx->va_ctx, "sampler:%s", name));
return sampler;
}
VkDescriptorSetLayout
Vulkan_CreateDescriptorSetLayout(vulkan_ctx_t *ctx, const char *name)
{
scriptctx_t *sctx = ctx->script_context;
hashtab_t *tab = sctx->setLayouts;
const char *path;
path = va (ctx->va_ctx, "$"QFV_PROPERTIES".setLayouts.%s", name);
__auto_type set = (VkDescriptorSetLayout) QFV_GetHandle (tab, path);
if (set) {
return set;
}
plitem_t *item = qfv_load_pipeline (ctx, "setLayouts");
if (!(item = PL_ObjectForKey (item, name))) {
Sys_Printf ("error loading descriptor set %s\n", name);
return 0;
} else {
Sys_MaskPrintf (SYS_vulkan_parse, "Found descriptor set def %s\n",
name);
}
set = QFV_ParseDescriptorSetLayout (ctx, item, sctx->pipelineDef);
QFV_AddHandle (tab, path, (uint64_t) set);
QFV_duSetObjectName (ctx->device, VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT,
set, va (ctx->va_ctx, "descriptor_set:%s", name));
return set;
}
[vulkan] Add initial render info parser It doesn't work yet, but I've some otherwise breaking changes I want in (getting this in now prevents the breakage).
2023-02-09 12:17:04 +00:00
[vulkan] Create a function for symtab creation Most importantly, this cleans up creation of self-referencing symbol tables from property lists, but adds in C-defined symbols as well. While QFV_ParseRenderInfo is currently the only the function that uses it, it might be helpful in the future, especially as I clean up the other parse support code.
2023-02-26 04:51:24 +00:00
exprtab_t *
QFV_CreateSymtab (plitem_t *dict, const char *properties,
const char **extra_items, exprsym_t *extra_syms,
exprctx_t *ectx)
{
plitem_t *props = PL_ObjectForKey (dict, properties);
int num_keys = PL_D_NumKeys (props);
int num_extra = 0;
int num_syms = 0;
[vulkan] Allow null extra items and symbols Don't want to have to pass empty lists.
2023-02-26 17:53:03 +00:00
if (extra_items) {
for (const char **e = extra_items; *e; e++) {
if (PL_ObjectForKey (dict, *e)) {
num_extra++;
}
[vulkan] Create a function for symtab creation Most importantly, this cleans up creation of self-referencing symbol tables from property lists, but adds in C-defined symbols as well. While QFV_ParseRenderInfo is currently the only the function that uses it, it might be helpful in the future, especially as I clean up the other parse support code.
2023-02-26 04:51:24 +00:00
}
}
[vulkan] Allow null extra items and symbols Don't want to have to pass empty lists.
2023-02-26 17:53:03 +00:00
if (extra_syms) {
for (exprsym_t *sym = extra_syms; sym->name; sym++, num_syms++) { }
}
[vulkan] Create a function for symtab creation Most importantly, this cleans up creation of self-referencing symbol tables from property lists, but adds in C-defined symbols as well. While QFV_ParseRenderInfo is currently the only the function that uses it, it might be helpful in the future, especially as I clean up the other parse support code.
2023-02-26 04:51:24 +00:00
int total_items = num_keys + num_extra;
int total_syms = total_items + num_syms;
size_t size = (sizeof (exprtab_t)
+ (total_syms + 1) * sizeof (exprsym_t)
+ total_items * sizeof (plitem_t *));
exprtab_t *symtab = malloc (size);
*symtab = (exprtab_t) {
.symbols = (exprsym_t *) &symtab[1],
};
plitem_t **items = (plitem_t **) &symtab->symbols[total_syms + 1];
for (int i = 0; i < num_keys; i++) {
symtab->symbols[i] = (exprsym_t) {
.name = PL_KeyAtIndex (props, i),
.type = &cexpr_plitem,
.value = items + i,
};
items[i] = PL_ObjectForKey (props, symtab->symbols[i].name);
}
[vulkan] Allow null extra items and symbols Don't want to have to pass empty lists.
2023-02-26 17:53:03 +00:00
for (int i = 0, j = 0; num_extra && extra_items[i]; i++) {
[vulkan] Create a function for symtab creation Most importantly, this cleans up creation of self-referencing symbol tables from property lists, but adds in C-defined symbols as well. While QFV_ParseRenderInfo is currently the only the function that uses it, it might be helpful in the future, especially as I clean up the other parse support code.
2023-02-26 04:51:24 +00:00
plitem_t *val = PL_ObjectForKey (dict, extra_items[i]);
if (val) {
symtab->symbols[num_keys + j] = (exprsym_t) {
.name = extra_items[i],
.type = &cexpr_plitem,
[vulkan] Use correct index for pl item setup Due to a typo in the list of extra property list items to add to the symbol table (corrected), subsequent symbols were pointing to the wrong memory address.
2023-02-27 06:00:40 +00:00
.value = items + num_keys + j,
[vulkan] Create a function for symtab creation Most importantly, this cleans up creation of self-referencing symbol tables from property lists, but adds in C-defined symbols as well. While QFV_ParseRenderInfo is currently the only the function that uses it, it might be helpful in the future, especially as I clean up the other parse support code.
2023-02-26 04:51:24 +00:00
};
items[num_keys + j] = val;
j++;
}
}
for (int i = 0; i < num_syms; i++) {
symtab->symbols[total_items + i] = extra_syms[i];
}
symtab->symbols[total_syms] = (exprsym_t) { };
cexpr_init_symtab (symtab, ectx);
return symtab;
}
void
QFV_DestroySymtab (exprtab_t *tab)
{
Hash_DelTable (tab->tab);
free (tab);
}
[vulkan] Add initial render info parser It doesn't work yet, but I've some otherwise breaking changes I want in (getting this in now prevents the breakage).
2023-02-09 12:17:04 +00:00
qfv_renderinfo_t *
[vulkan] Implement task function parsing This just sets up the memory block and cexpr descriptors for the parameters, parameter parsing is separate (and next). The parameters are aligned to their size.
2023-02-12 16:43:17 +00:00
QFV_ParseRenderInfo (vulkan_ctx_t *ctx, plitem_t *item, qfv_renderctx_t *rctx)
[vulkan] Add initial render info parser It doesn't work yet, but I've some otherwise breaking changes I want in (getting this in now prevents the breakage).
2023-02-09 12:17:04 +00:00
{
memsuper_t *memsuper = new_memsuper ();
qfv_renderinfo_t *ri = cmemalloc (memsuper, sizeof (qfv_renderinfo_t));
*ri = (qfv_renderinfo_t) { .memsuper = memsuper };
scriptctx_t *sctx = ctx->script_context;
plitem_t *messages = PL_NewArray ();
[vulkan] Create a function for symtab creation Most importantly, this cleans up creation of self-referencing symbol tables from property lists, but adds in C-defined symbols as well. While QFV_ParseRenderInfo is currently the only the function that uses it, it might be helpful in the future, especially as I clean up the other parse support code.
2023-02-26 04:51:24 +00:00
exprctx_t exprctx = {
.symtab = &root_symtab,
.messages = messages,
.hashctx = &sctx->hashctx,
.memsuper = memsuper,
};
[vulkan] Implement task function parsing This just sets up the memory block and cexpr descriptors for the parameters, parameter parsing is separate (and next). The parameters are aligned to their size.
2023-02-12 16:43:17 +00:00
parsectx_t parsectx = {
.ectx = &exprctx,
.vctx = ctx,
[vulkan] Create a function for symtab creation Most importantly, this cleans up creation of self-referencing symbol tables from property lists, but adds in C-defined symbols as well. While QFV_ParseRenderInfo is currently the only the function that uses it, it might be helpful in the future, especially as I clean up the other parse support code.
2023-02-26 04:51:24 +00:00
.data = rctx,
[vulkan] Implement task function parsing This just sets up the memory block and cexpr descriptors for the parameters, parameter parsing is separate (and next). The parameters are aligned to their size.
2023-02-12 16:43:17 +00:00
};
[vulkan] Add initial render info parser It doesn't work yet, but I've some otherwise breaking changes I want in (getting this in now prevents the breakage).
2023-02-09 12:17:04 +00:00
[vulkan] Create a function for symtab creation Most importantly, this cleans up creation of self-referencing symbol tables from property lists, but adds in C-defined symbols as well. While QFV_ParseRenderInfo is currently the only the function that uses it, it might be helpful in the future, especially as I clean up the other parse support code.
2023-02-26 04:51:24 +00:00
static const char *extra_items[] = {
"images",
[vulkan] Use correct index for pl item setup Due to a typo in the list of extra property list items to add to the symbol table (corrected), subsequent symbols were pointing to the wrong memory address.
2023-02-27 06:00:40 +00:00
"views",
[vulkan] Create a function for symtab creation Most importantly, this cleans up creation of self-referencing symbol tables from property lists, but adds in C-defined symbols as well. While QFV_ParseRenderInfo is currently the only the function that uses it, it might be helpful in the future, especially as I clean up the other parse support code.
2023-02-26 04:51:24 +00:00
"renderpasses",
0
[vulkan] Add initial render info parser It doesn't work yet, but I've some otherwise breaking changes I want in (getting this in now prevents the breakage).
2023-02-09 12:17:04 +00:00
};
[vulkan] Create a function for symtab creation Most importantly, this cleans up creation of self-referencing symbol tables from property lists, but adds in C-defined symbols as well. While QFV_ParseRenderInfo is currently the only the function that uses it, it might be helpful in the future, especially as I clean up the other parse support code.
2023-02-26 04:51:24 +00:00
exprsym_t var_syms[] = {
{"output", &qfv_output_t_type, &sctx->output},
{"frames", &vulkan_frameset_t_type, &ctx->frames},
{"msaaSamples", &VkSampleCountFlagBits_type, &ctx->msaaSamples},
{"physDevLimits", &VkPhysicalDeviceLimits_type,
&ctx->device->physDev->properties->limits },
{}
[vulkan] Add initial render info parser It doesn't work yet, but I've some otherwise breaking changes I want in (getting this in now prevents the breakage).
2023-02-09 12:17:04 +00:00
};
[vulkan] Create a function for symtab creation Most importantly, this cleans up creation of self-referencing symbol tables from property lists, but adds in C-defined symbols as well. While QFV_ParseRenderInfo is currently the only the function that uses it, it might be helpful in the future, especially as I clean up the other parse support code.
2023-02-26 04:51:24 +00:00
exprctx.external_variables = QFV_CreateSymtab (item, "properties",
extra_items, var_syms,
&exprctx);
[vulkan] Add initial render info parser It doesn't work yet, but I've some otherwise breaking changes I want in (getting this in now prevents the breakage).
2023-02-09 12:17:04 +00:00
int ret;
if (!(ret = parse_qfv_renderinfo_t (0, item, ri, messages, &parsectx))) {
for (int i = 0; i < PL_A_NumObjects (messages); i++) {
Sys_Printf ("%s\n", PL_String (PL_ObjectAtIndex (messages, i)));
[vulkan] Start work on a render job system The jobs will become the core of the renderer, with each job step being one of a render pass, compute pass, or processor (CPU-only) task. The steps support dependencies, which will allow for threading the system in the future. Currently, just the structures, parse support, and prototype job specification (render.plist) have been implemented. No conversion to working data is done yet, and many things, in particular resources, will need to be reworked, but this gets the basic design in.
2023-03-10 10:47:40 +00:00
}
}
QFV_DestroySymtab (exprctx.external_variables);
[plist] Use reference counts for items This makes it much easier to share items between property lists (eg, targets and the main entity list in cl_light).
2023-03-12 06:17:28 +00:00
PL_Release (messages);
[vulkan] Start work on a render job system The jobs will become the core of the renderer, with each job step being one of a render pass, compute pass, or processor (CPU-only) task. The steps support dependencies, which will allow for threading the system in the future. Currently, just the structures, parse support, and prototype job specification (render.plist) have been implemented. No conversion to working data is done yet, and many things, in particular resources, will need to be reworked, but this gets the basic design in.
2023-03-10 10:47:40 +00:00
if (!ret) {
delete_memsuper (memsuper);
ri = 0;
}
return ri;
}
struct qfv_jobinfo_s *
QFV_ParseJobInfo (vulkan_ctx_t *ctx, plitem_t *item, qfv_renderctx_t *rctx)
{
memsuper_t *memsuper = new_memsuper ();
qfv_jobinfo_t *ri = cmemalloc (memsuper, sizeof (qfv_jobinfo_t));
*ri = (qfv_jobinfo_t) { .memsuper = memsuper };
scriptctx_t *sctx = ctx->script_context;
plitem_t *messages = PL_NewArray ();
exprctx_t exprctx = {
.symtab = &root_symtab,
.messages = messages,
.hashctx = &sctx->hashctx,
.memsuper = memsuper,
};
parsectx_t parsectx = {
.ectx = &exprctx,
.vctx = ctx,
.data = rctx,
};
static const char *extra_items[] = {
"images",
"views",
"renderpasses",
0
};
exprsym_t var_syms[] = {
{"output", &qfv_output_t_type, &sctx->output},
{"frames", &vulkan_frameset_t_type, &ctx->frames},
{"msaaSamples", &VkSampleCountFlagBits_type, &ctx->msaaSamples},
{"physDevLimits", &VkPhysicalDeviceLimits_type,
&ctx->device->physDev->properties->limits },
{}
};
exprctx.external_variables = QFV_CreateSymtab (item, "properties",
extra_items, var_syms,
&exprctx);
int ret;
if (!(ret = parse_qfv_jobinfo_t (0, item, ri, messages, &parsectx))) {
for (int i = 0; i < PL_A_NumObjects (messages); i++) {
Sys_Printf ("%s\n", PL_String (PL_ObjectAtIndex (messages, i)));
[vulkan] Add initial render info parser It doesn't work yet, but I've some otherwise breaking changes I want in (getting this in now prevents the breakage).
2023-02-09 12:17:04 +00:00
}
}
[vulkan] Create a function for symtab creation Most importantly, this cleans up creation of self-referencing symbol tables from property lists, but adds in C-defined symbols as well. While QFV_ParseRenderInfo is currently the only the function that uses it, it might be helpful in the future, especially as I clean up the other parse support code.
2023-02-26 04:51:24 +00:00
QFV_DestroySymtab (exprctx.external_variables);
[plist] Use reference counts for items This makes it much easier to share items between property lists (eg, targets and the main entity list in cl_light).
2023-03-12 06:17:28 +00:00
PL_Release (messages);
[vulkan] Implement task function parsing This just sets up the memory block and cexpr descriptors for the parameters, parameter parsing is separate (and next). The parameters are aligned to their size.
2023-02-12 16:43:17 +00:00
if (!ret) {
[vulkan] Get render pass inheritance working Needed to add the render passes plitem to the cexr symbol table, too. All that remains is to figure out how to deal with multiview (or really @next) and get task parsing working.
2023-02-11 17:43:38 +00:00
delete_memsuper (memsuper);
[vulkan] Implement task function parsing This just sets up the memory block and cexpr descriptors for the parameters, parameter parsing is separate (and next). The parameters are aligned to their size.
2023-02-12 16:43:17 +00:00
ri = 0;
[vulkan] Get render pass inheritance working Needed to add the render passes plitem to the cexr symbol table, too. All that remains is to figure out how to deal with multiview (or really @next) and get task parsing working.
2023-02-11 17:43:38 +00:00
}
[vulkan] Add initial render info parser It doesn't work yet, but I've some otherwise breaking changes I want in (getting this in now prevents the breakage).
2023-02-09 12:17:04 +00:00
[vulkan] Get render pass inheritance working Needed to add the render passes plitem to the cexr symbol table, too. All that remains is to figure out how to deal with multiview (or really @next) and get task parsing working.
2023-02-11 17:43:38 +00:00
return ri;
[vulkan] Add initial render info parser It doesn't work yet, but I've some otherwise breaking changes I want in (getting this in now prevents the breakage).
2023-02-09 12:17:04 +00:00
}
[vulkan] Support parsing pipeline layout info This is for the new system.
2023-02-26 17:54:51 +00:00
int
QFV_ParseLayoutInfo (vulkan_ctx_t *ctx, memsuper_t *memsuper,
exprtab_t *symtab, const char *ref,
qfv_layoutinfo_t *layout)
{
*layout = (qfv_layoutinfo_t) {};
scriptctx_t *sctx = ctx->script_context;
plitem_t *messages = PL_NewArray ();
exprctx_t exprctx = {
.symtab = &root_symtab,
.messages = messages,
.hashctx = &sctx->hashctx,
.memsuper = memsuper,
.external_variables = symtab,
};
parsectx_t parsectx = {
.ectx = &exprctx,
.vctx = ctx,
};
plitem_t *item = PL_NewString (ref);
int ret;
if (!(ret = parse_qfv_layoutinfo_t (0, item, layout, messages,
&parsectx))) {
for (int i = 0; i < PL_A_NumObjects (messages); i++) {
Sys_Printf ("%s\n", PL_String (PL_ObjectAtIndex (messages, i)));
}
}
[plist] Use reference counts for items This makes it much easier to share items between property lists (eg, targets and the main entity list in cl_light).
2023-03-12 06:17:28 +00:00
PL_Release (messages);
PL_Release (item);
[vulkan] Support parsing pipeline layout info This is for the new system.
2023-02-26 17:54:51 +00:00
return ret;
}
Reference in a new issue Copy permalink