mirror of
https://git.code.sf.net/p/quake/quakeforge
synced 2024-12-11 21:31:30 +00:00
5140346c22
Gotta be sure :) With the new system mostly up and running (just bsp rendering and descriptor sets/layout handling to go, and they're independent of the old render pass system), the old system can finally be cleared out.
2324 lines
63 KiB
C
2324 lines
63 KiB
C
/*
|
|
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
|
|
|
|
#include <string.h>
|
|
|
|
#include "QF/cmem.h"
|
|
#include "QF/cvar.h"
|
|
#include "QF/dstring.h"
|
|
#include "QF/hash.h"
|
|
#include "QF/mathlib.h"
|
|
#include "QF/va.h"
|
|
|
|
#include "QF/Vulkan/debug.h"
|
|
#include "QF/Vulkan/device.h"
|
|
#include "QF/Vulkan/instance.h"
|
|
#include "QF/Vulkan/image.h"
|
|
#include "QF/Vulkan/pipeline.h"
|
|
#include "QF/Vulkan/render.h"
|
|
#include "QF/Vulkan/shader.h"
|
|
|
|
#include "vid_vulkan.h"
|
|
|
|
#include "vkparse.h"
|
|
#include "libs/video/renderer/vulkan/vkparse.hinc"
|
|
|
|
typedef struct parseres_s {
|
|
const char *name;
|
|
plfield_t *field;
|
|
size_t offset;
|
|
} parseres_t;
|
|
|
|
typedef struct parseref_s {
|
|
const char *name;
|
|
plparser_t parse;
|
|
size_t size;
|
|
} parserref_t;
|
|
|
|
typedef struct handleref_s {
|
|
char *name;
|
|
uint64_t handle;
|
|
} handleref_t;
|
|
|
|
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 },
|
|
{ '=', &cexpr_plitem, 0, cexpr_cast_plitem },
|
|
{}
|
|
};
|
|
|
|
binop_t enum_binops[] = {
|
|
{ '=', &cexpr_plitem, 0, cexpr_cast_plitem },
|
|
{}
|
|
};
|
|
|
|
unop_t flag_unops[] = {
|
|
{ '~', 0, flag_not },
|
|
{}
|
|
};
|
|
|
|
typedef struct parse_single_s {
|
|
pltype_t type;
|
|
size_t stride;
|
|
plparser_t parser;
|
|
void *data;
|
|
size_t value_offset;
|
|
} parse_single_t;
|
|
|
|
typedef struct parse_array_s {
|
|
pltype_t type;
|
|
size_t stride;
|
|
plparser_t parser;
|
|
void *data;
|
|
size_t value_offset;
|
|
size_t size_offset;
|
|
} parse_array_t;
|
|
|
|
typedef struct parse_fixed_array_s {
|
|
pltype_t type;
|
|
size_t stride;
|
|
plparser_t parser;
|
|
void *data;
|
|
size_t size;
|
|
} parse_fixed_array_t;
|
|
|
|
typedef struct parse_data_s {
|
|
size_t value_offset;
|
|
size_t size_offset;
|
|
} parse_data_t;
|
|
|
|
typedef struct parse_string_s {
|
|
size_t value_offset;
|
|
} parse_string_t;
|
|
|
|
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;
|
|
|
|
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;
|
|
}
|
|
|
|
static int
|
|
parse_basic (const plfield_t *field, const plitem_t *item,
|
|
void *data, plitem_t *messages, void *context)
|
|
{
|
|
int ret = 1;
|
|
parsectx_t *pctx = context;
|
|
__auto_type etype = (exprtype_t *) field->data;
|
|
exprctx_t ectx = *pctx->ectx;
|
|
exprval_t result = { etype, data };
|
|
ectx.result = &result;
|
|
ectx.item = item;
|
|
const char *valstr = PL_String (item);
|
|
//Sys_MaskPrintf (SYS_vulkan_parse, "parse_basic: %s %zd %d %p %p: %s\n",
|
|
// field->name, field->offset, field->type, field->parser,
|
|
// field->data, valstr);
|
|
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);
|
|
if (!ret) {
|
|
PL_Message (messages, item, "error parsing %s: %s",
|
|
field->name, valstr);
|
|
}
|
|
}
|
|
//Sys_MaskPrintf (SYS_vulkan_parse, " %x\n", *(uint32_t *)data);
|
|
|
|
return ret;
|
|
}
|
|
|
|
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;
|
|
parsectx_t *pctx = context;
|
|
exprval_t result = { &cexpr_size_t, &val };
|
|
exprctx_t ectx = *pctx->ectx;
|
|
ectx.result = &result;
|
|
ectx.item = item;
|
|
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;
|
|
}
|
|
|
|
static int
|
|
parse_uint32_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;
|
|
parsectx_t *pctx = context;
|
|
exprval_t result = { &cexpr_size_t, &val };
|
|
exprctx_t ectx = *pctx->ectx;
|
|
ectx.result = &result;
|
|
ectx.item = item;
|
|
const char *valstr = PL_String (item);
|
|
//Sys_MaskPrintf (SYS_vulkan_parse, "parse_uint32_t: %s %zd %d %p %p: %s\n",
|
|
// field->name, field->offset, field->type, field->parser,
|
|
// field->data, valstr);
|
|
if (strcmp (valstr, "VK_SUBPASS_EXTERNAL") == 0) {
|
|
//FIXME handle subpass in a separate parser?
|
|
*(uint32_t *) data = VK_SUBPASS_EXTERNAL;
|
|
} else {
|
|
//Sys_MaskPrintf (SYS_vulkan_parse,
|
|
// "parse_uint32_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);
|
|
}
|
|
*(uint32_t *) data = val;
|
|
//Sys_MaskPrintf (SYS_vulkan_parse, " %d\n", *(uint32_t *)data);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int
|
|
parse_enum (const plfield_t *field, const plitem_t *item,
|
|
void *data, plitem_t *messages, void *context)
|
|
{
|
|
int ret = 1;
|
|
__auto_type enm = (exprenum_t *) field->data;
|
|
parsectx_t *pctx = context;
|
|
exprctx_t ectx = *pctx->ectx;
|
|
exprval_t result = { enm->type, data };
|
|
ectx.parent = pctx->ectx;
|
|
ectx.symtab = enm->symtab;
|
|
ectx.result = &result;
|
|
const char *valstr = PL_String (item);
|
|
//Sys_MaskPrintf (SYS_vulkan_parse, "parse_enum: %s %zd %d %p %p %s\n",
|
|
// field->name, field->offset, field->type, field->parser,
|
|
// field->data, valstr);
|
|
ret = !cexpr_parse_enum (enm, valstr, &ectx, data);
|
|
if (!ret) {
|
|
PL_Message (messages, item, "error parsing enum: %s", valstr);
|
|
}
|
|
//Sys_MaskPrintf (SYS_vulkan_parse, " %d\n", *(int *)data);
|
|
return ret;
|
|
}
|
|
|
|
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;
|
|
ectx.item = item;
|
|
const char *name = PL_String (item);
|
|
if (cexpr_eval_string (name, &ectx)) {
|
|
PL_Message (messages, item, "not a %s reference", type);
|
|
return 0;
|
|
}
|
|
return refItem;
|
|
}
|
|
|
|
static void *
|
|
vkparse_alloc (void *context, size_t size)
|
|
{
|
|
parsectx_t *pctx = context;
|
|
return cmemalloc (pctx->ectx->memsuper, size);
|
|
}
|
|
|
|
static int
|
|
parse_ignore (const plfield_t *field, const plitem_t *item,
|
|
void *data, plitem_t *messages, void *context)
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
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);
|
|
|
|
const char *key = PL_KeyAtIndex (item, 0);
|
|
if (!key) {
|
|
PL_Message (messages, item, "missing item");
|
|
return 0;
|
|
}
|
|
item = PL_ObjectForKey (item, key);
|
|
|
|
if (!PL_CheckType (single->type, PL_Type (item))) {
|
|
PL_TypeMismatch (messages, item, field->name, single->type,
|
|
PL_Type (item));
|
|
return 0;
|
|
}
|
|
|
|
plfield_t f = { field->name, 0, single->type, single->parser, 0 };
|
|
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;
|
|
}
|
|
|
|
static int
|
|
parse_single (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_single: %s %zd %d %p %p\n",
|
|
// field->name, field->offset,
|
|
// field->type, field->parser, field->data);
|
|
|
|
if (!PL_CheckType (single->type, PL_Type (item))) {
|
|
PL_TypeMismatch (messages, item, field->name, single->type,
|
|
PL_Type (item));
|
|
return 0;
|
|
}
|
|
|
|
plfield_t f = { field->name, 0, single->type, single->parser, 0 };
|
|
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;
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
static int
|
|
parse_array (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_ParseArray (&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;
|
|
}
|
|
|
|
static int __attribute__((used))
|
|
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,
|
|
array->data,
|
|
};
|
|
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;
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
static __attribute__((used)) parse_string_t parse_string_array = { 0 };
|
|
|
|
static int
|
|
parse_string (const plfield_t *field, const plitem_t *item,
|
|
void *data, plitem_t *messages, void *context)
|
|
{
|
|
__auto_type string = (parse_string_t *) field->data;
|
|
__auto_type value = (char **) ((byte *)data + string->value_offset);
|
|
|
|
const char *str = PL_String (item);
|
|
|
|
//Sys_MaskPrintf (SYS_vulkan_parse, "parse_string: %s %zd %d %p %p %p\n",
|
|
// field->name, field->offset, field->type, field->parser,
|
|
// field->data, data);
|
|
//Sys_MaskPrintf (SYS_vulkan_parse, " %zd\n", string->value_offset);
|
|
//Sys_MaskPrintf (SYS_vulkan_parse, " %s\n", str);
|
|
|
|
*value = vkstrdup (context, str);
|
|
return 1;
|
|
}
|
|
|
|
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);
|
|
}
|
|
|
|
static int
|
|
parse_inherit (const plfield_t *field, const plitem_t *item,
|
|
void *data, plitem_t *messages, void *context)
|
|
{
|
|
parsectx_t *pctx = context;
|
|
exprctx_t ectx = *pctx->ectx;
|
|
plitem_t *inheritItem = 0;
|
|
exprval_t result = { &cexpr_plitem, &inheritItem };
|
|
ectx.result = &result;
|
|
ectx.item = item;
|
|
const char *inheritstr = PL_String (item);
|
|
//Sys_MaskPrintf (SYS_vulkan_parse, "parse_inherit: %s\n", inheritstr);
|
|
int ret = !cexpr_eval_string (inheritstr, &ectx);
|
|
if (ret) {
|
|
ret = PL_ParseStruct (field->data, inheritItem, data, messages,
|
|
context);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
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;
|
|
ectx.item = item;
|
|
const char *valstr = PL_String (item);
|
|
//Sys_MaskPrintf (SYS_vulkan_parse, "parse_RGBA: %s\n", valstr);
|
|
ret = !cexpr_eval_string (valstr, &ectx);
|
|
//Sys_MaskPrintf (SYS_vulkan_parse, " "VEC4F_FMT"\n",
|
|
// VEC4_EXP (*(vec4f_t *)data[0]));
|
|
return ret;
|
|
}
|
|
|
|
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)
|
|
{
|
|
handleref_t *hr = malloc (sizeof (handleref_t));
|
|
hr->name = strdup (name);
|
|
hr->handle = handle;
|
|
Hash_Add (tab, hr);
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
static int
|
|
parse_VkRenderPass (const plitem_t *item, void **data,
|
|
plitem_t *messages, parsectx_t *pctx)
|
|
{
|
|
__auto_type handle = (VkRenderPass *) data[0];
|
|
int ret = 1;
|
|
exprctx_t ectx = *pctx->ectx;
|
|
vulkan_ctx_t *ctx = pctx->vctx;
|
|
scriptctx_t *sctx = ctx->script_context;
|
|
|
|
const char *name = PL_String (item);
|
|
const char *path = resource_path (ctx, 0, name);
|
|
Sys_MaskPrintf (SYS_vulkan_parse, "parse_VkRenderPass: %s\n", path);
|
|
|
|
*handle = (VkRenderPass) QFV_GetHandle (sctx->renderpasses, path);
|
|
if (*handle) {
|
|
return 1;
|
|
}
|
|
|
|
plitem_t *setItem = 0;
|
|
exprval_t result = { &cexpr_plitem, &setItem };
|
|
ectx.result = &result;
|
|
ectx.item = item;
|
|
ret = !cexpr_eval_string (path, &ectx);
|
|
if (ret) {
|
|
VkRenderPass setLayout;
|
|
setLayout = QFV_ParseRenderPass (ctx, setItem, pctx->properties);
|
|
*handle = (VkRenderPass) setLayout;
|
|
|
|
// path not guaranteed to survive cexpr_eval_string due to va
|
|
path = resource_path (ctx, 0, name);
|
|
QFV_AddHandle (sctx->renderpasses, path, (uint64_t) setLayout);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
static int
|
|
parse_VkShaderModule (const plitem_t *item, void **data,
|
|
plitem_t *messages, parsectx_t *pctx)
|
|
{
|
|
__auto_type handle = (VkShaderModule *) data[0];
|
|
vulkan_ctx_t *ctx = pctx->vctx;
|
|
qfv_device_t *device = ctx->device;
|
|
scriptctx_t *sctx = ctx->script_context;
|
|
|
|
const char *name = PL_String (item);
|
|
*handle = (VkShaderModule) QFV_GetHandle (sctx->shaderModules, name);
|
|
if (*handle) {
|
|
return 1;
|
|
}
|
|
qfvPushDebug (ctx, va (ctx->va_ctx, "parse_VkShaderModule: %d", PL_Line (item)));
|
|
*handle = QFV_CreateShaderModule (device, name);
|
|
qfvPopDebug (ctx);
|
|
if (!*handle) {
|
|
PL_Message (messages, item, "could not find shader %s", name);
|
|
return 0;
|
|
}
|
|
QFV_AddHandle (sctx->shaderModules, name, (uint64_t) *handle);
|
|
return 1;
|
|
}
|
|
|
|
static int
|
|
parse_VkDescriptorSetLayout (const plfield_t *field, const plitem_t *item,
|
|
void *data, plitem_t *messages, void *context)
|
|
{
|
|
__auto_type handle = (VkDescriptorSetLayout *) data;
|
|
int ret = 1;
|
|
parsectx_t *pctx = context;
|
|
exprctx_t ectx = *pctx->ectx;
|
|
vulkan_ctx_t *ctx = pctx->vctx;
|
|
scriptctx_t *sctx = ctx->script_context;
|
|
|
|
const char *name = PL_String (item);
|
|
const char *path = resource_path (ctx, "setLayouts", name);
|
|
Sys_MaskPrintf (SYS_vulkan_parse, "parse_VkDescriptorSetLayout: %s\n",
|
|
path);
|
|
|
|
*handle = (VkDescriptorSetLayout) QFV_GetHandle (sctx->setLayouts, path);
|
|
if (*handle) {
|
|
return 1;
|
|
}
|
|
|
|
plitem_t *setItem = 0;
|
|
exprval_t result = { &cexpr_plitem, &setItem };
|
|
ectx.result = &result;
|
|
ectx.item = item;
|
|
ret = !cexpr_eval_string (path, &ectx);
|
|
if (ret) {
|
|
VkDescriptorSetLayout setLayout;
|
|
setLayout = QFV_ParseDescriptorSetLayout (ctx, setItem,
|
|
pctx->properties);
|
|
*handle = (VkDescriptorSetLayout) setLayout;
|
|
|
|
// path not guaranteed to survive cexpr_eval_string due to va
|
|
path = resource_path (ctx, "setLayouts", name);
|
|
QFV_AddHandle (sctx->setLayouts, path, (uint64_t) setLayout);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
static int
|
|
parse_VkPipelineLayout (const plitem_t *item, void **data,
|
|
plitem_t *messages, parsectx_t *pctx)
|
|
{
|
|
__auto_type handle = (VkPipelineLayout *) data[0];
|
|
int ret = 1;
|
|
exprctx_t ectx = *pctx->ectx;
|
|
vulkan_ctx_t *ctx = pctx->vctx;
|
|
scriptctx_t *sctx = ctx->script_context;
|
|
|
|
const char *name = PL_String (item);
|
|
const char *path = resource_path (ctx, "pipelineLayouts", name);
|
|
Sys_MaskPrintf (SYS_vulkan_parse, "parse_VkPipelineLayout: %s\n", path);
|
|
|
|
*handle = (VkPipelineLayout) QFV_GetHandle (sctx->pipelineLayouts, path);
|
|
if (*handle) {
|
|
return 1;
|
|
}
|
|
|
|
plitem_t *setItem = 0;
|
|
exprval_t result = { &cexpr_plitem, &setItem };
|
|
ectx.result = &result;
|
|
ectx.item = item;
|
|
ret = !cexpr_eval_string (path, &ectx);
|
|
if (ret) {
|
|
VkPipelineLayout layout;
|
|
layout = QFV_ParsePipelineLayout (ctx, setItem, pctx->properties);
|
|
*handle = (VkPipelineLayout) layout;
|
|
|
|
// path not guaranteed to survive cexpr_eval_string due to va
|
|
path = resource_path (ctx, "pipelineLayouts", name);
|
|
QFV_AddHandle (sctx->pipelineLayouts, path, (uint64_t) layout);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
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
|
|
};
|
|
|
|
static int
|
|
parse_VkImage (const plitem_t *item, void **data, plitem_t *messages,
|
|
parsectx_t *pctx)
|
|
{
|
|
__auto_type handle = (VkImage *) data[0];
|
|
int ret = 1;
|
|
exprctx_t ectx = *pctx->ectx;
|
|
vulkan_ctx_t *ctx = pctx->vctx;
|
|
scriptctx_t *sctx = ctx->script_context;
|
|
|
|
const char *name = PL_String (item);
|
|
const char *path = resource_path (ctx, "images", name);
|
|
Sys_MaskPrintf (SYS_vulkan_parse, "parse_VkImage: %s\n", path);
|
|
|
|
*handle = (VkImage) QFV_GetHandle (sctx->images, path);
|
|
if (*handle) {
|
|
return 1;
|
|
}
|
|
|
|
exprval_t result = { };
|
|
ectx.result = &result;
|
|
ectx.item = item;
|
|
ret = !cexpr_eval_string (path, &ectx);
|
|
if (ret) {
|
|
if (result.type == &cexpr_plitem) {
|
|
plitem_t *imageItem = *(plitem_t **) result.value;
|
|
VkImage image;
|
|
image = QFV_ParseImage (ctx, imageItem, pctx->properties);
|
|
*handle = (VkImage) image;
|
|
|
|
// 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;
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
static int
|
|
parse_VkImageView (const plfield_t *field, const plitem_t *item, void *data,
|
|
plitem_t *messages, void *context)
|
|
{
|
|
parsectx_t *pctx = context;
|
|
__auto_type handle = (VkImageView *) data;
|
|
int ret = 1;
|
|
exprctx_t ectx = *pctx->ectx;
|
|
vulkan_ctx_t *ctx = pctx->vctx;
|
|
scriptctx_t *sctx = ctx->script_context;
|
|
|
|
const char *name = PL_String (item);
|
|
const char *path = resource_path (ctx, "imageViews", name);
|
|
Sys_MaskPrintf (SYS_vulkan_parse, "parse_VkImageView: %s\n", path);
|
|
|
|
*handle = (VkImageView) QFV_GetHandle (sctx->imageViews, path);
|
|
if (*handle) {
|
|
return 1;
|
|
}
|
|
|
|
exprval_t *value = 0;
|
|
exprval_t result = { &cexpr_exprval, &value };
|
|
ectx.result = &result;
|
|
ectx.item = item;
|
|
ret = !cexpr_eval_string (path, &ectx);
|
|
|
|
plitem_t *imageViewItem = 0;
|
|
if (ret) {
|
|
VkImageView imageView;
|
|
if (value->type == &VkImageView_type) {
|
|
imageView = *(VkImageView *) value->value;
|
|
} else if (value->type == &cexpr_plitem) {
|
|
imageView = QFV_ParseImageView (ctx, imageViewItem,
|
|
pctx->properties);
|
|
// path not guaranteed to survive cexpr_eval_string due to va
|
|
path = resource_path (ctx, "imageViews", name);
|
|
QFV_AddHandle (sctx->imageViews, path, (uint64_t) imageView);
|
|
} else {
|
|
PL_Message (messages, item, "not a VkImageView");
|
|
return 0;
|
|
}
|
|
*handle = (VkImageView) imageView;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
static const char *
|
|
handleref_getkey (const void *hr, void *unused)
|
|
{
|
|
return ((handleref_t *)hr)->name;
|
|
}
|
|
|
|
static void
|
|
handleref_free (void *hr, void *_ctx)
|
|
{
|
|
__auto_type handleref = (handleref_t *) hr;
|
|
free (handleref->name);
|
|
free (handleref);
|
|
}
|
|
|
|
static void
|
|
setLayout_free (void *hr, void *_ctx)
|
|
{
|
|
scriptctx_t *sctx = _ctx;
|
|
__auto_type handleref = (handleref_t *) hr;
|
|
__auto_type layout = (VkDescriptorSetLayout) handleref->handle;
|
|
__auto_type ctx = sctx->vctx;
|
|
qfv_device_t *device = ctx->device;
|
|
qfv_devfuncs_t *dfunc = device->funcs;
|
|
|
|
if (layout) {
|
|
dfunc->vkDestroyDescriptorSetLayout (device->dev, layout, 0);
|
|
}
|
|
handleref_free (handleref, ctx);
|
|
}
|
|
|
|
static void
|
|
shaderModule_free (void *hr, void *_ctx)
|
|
{
|
|
scriptctx_t *sctx = _ctx;
|
|
__auto_type handleref = (handleref_t *) hr;
|
|
__auto_type module = (VkShaderModule) handleref->handle;
|
|
__auto_type ctx = sctx->vctx;
|
|
qfv_device_t *device = ctx->device;
|
|
qfv_devfuncs_t *dfunc = device->funcs;
|
|
|
|
if (module) {
|
|
dfunc->vkDestroyShaderModule (device->dev, module, 0);
|
|
}
|
|
handleref_free (handleref, ctx);
|
|
}
|
|
|
|
static void
|
|
pipelineLayout_free (void *hr, void *_ctx)
|
|
{
|
|
scriptctx_t *sctx = _ctx;
|
|
__auto_type handleref = (handleref_t *) hr;
|
|
__auto_type layout = (VkPipelineLayout) handleref->handle;
|
|
__auto_type ctx = sctx->vctx;
|
|
qfv_device_t *device = ctx->device;
|
|
qfv_devfuncs_t *dfunc = device->funcs;
|
|
|
|
if (layout) {
|
|
dfunc->vkDestroyPipelineLayout (device->dev, layout, 0);
|
|
};
|
|
handleref_free (handleref, ctx);
|
|
}
|
|
|
|
static void
|
|
descriptorPool_free (void *hr, void *_ctx)
|
|
{
|
|
scriptctx_t *sctx = _ctx;
|
|
__auto_type handleref = (handleref_t *) hr;
|
|
__auto_type pool = (VkDescriptorPool) handleref->handle;
|
|
__auto_type ctx = sctx->vctx;
|
|
qfv_device_t *device = ctx->device;
|
|
qfv_devfuncs_t *dfunc = device->funcs;
|
|
|
|
if (pool) {
|
|
dfunc->vkDestroyDescriptorPool (device->dev, pool, 0);
|
|
};
|
|
handleref_free (handleref, ctx);
|
|
}
|
|
|
|
static void
|
|
sampler_free (void *hr, void *_ctx)
|
|
{
|
|
scriptctx_t *sctx = _ctx;
|
|
__auto_type handleref = (handleref_t *) hr;
|
|
__auto_type sampler = (VkSampler) handleref->handle;
|
|
__auto_type ctx = sctx->vctx;
|
|
qfv_device_t *device = ctx->device;
|
|
qfv_devfuncs_t *dfunc = device->funcs;
|
|
|
|
if (sampler) {
|
|
dfunc->vkDestroySampler (device->dev, sampler, 0);
|
|
};
|
|
handleref_free (handleref, ctx);
|
|
}
|
|
|
|
static void
|
|
image_free (void *hr, void *_ctx)
|
|
{
|
|
scriptctx_t *sctx = _ctx;
|
|
__auto_type handleref = (handleref_t *) hr;
|
|
__auto_type image = (VkImage) handleref->handle;
|
|
__auto_type ctx = sctx->vctx;
|
|
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)
|
|
{
|
|
scriptctx_t *sctx = _ctx;
|
|
__auto_type handleref = (handleref_t *) hr;
|
|
__auto_type imageView = (VkImageView) handleref->handle;
|
|
__auto_type ctx = sctx->vctx;
|
|
qfv_device_t *device = ctx->device;
|
|
qfv_devfuncs_t *dfunc = device->funcs;
|
|
|
|
if (imageView) {
|
|
dfunc->vkDestroyImageView (device->dev, imageView, 0);
|
|
};
|
|
handleref_free (handleref, ctx);
|
|
}
|
|
|
|
static void
|
|
renderpass_free (void *hr, void *_ctx)
|
|
{
|
|
scriptctx_t *sctx = _ctx;
|
|
__auto_type handleref = (handleref_t *) hr;
|
|
__auto_type renderpass = (VkRenderPass) handleref->handle;
|
|
__auto_type ctx = sctx->vctx;
|
|
qfv_device_t *device = ctx->device;
|
|
qfv_devfuncs_t *dfunc = device->funcs;
|
|
|
|
if (renderpass) {
|
|
dfunc->vkDestroyRenderPass (device->dev, renderpass, 0);
|
|
};
|
|
handleref_free (handleref, ctx);
|
|
}
|
|
|
|
static hashtab_t *enum_symtab;
|
|
|
|
static int
|
|
parse_BasePipeline (const plitem_t *item, void **data,
|
|
plitem_t *messages, parsectx_t *pctx)
|
|
{
|
|
*(VkPipeline *) data = 0;
|
|
PL_Message (messages, item, "not implemented");
|
|
return 0;
|
|
}
|
|
|
|
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;
|
|
// params are in reverse order, but this works for calculating the size
|
|
// of the buffer
|
|
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;
|
|
// pre-decrement offset because params are in reverse order
|
|
offset -= size;
|
|
memcpy (data->a + offset, (*param)->value, size);
|
|
}
|
|
*(data_array_t **) result->value = data;
|
|
}
|
|
|
|
static exprtype_t data_array_type = {
|
|
.name = "array",
|
|
.size = sizeof (data_array_t *),
|
|
.binops = 0,
|
|
.unops = 0,
|
|
};
|
|
static exprfunc_t data_array_func[] = {
|
|
{ &data_array_type, -1, 0, data_array },
|
|
{}
|
|
};
|
|
static exprsym_t data_array_symbols[] = {
|
|
{ "array", &cexpr_function, data_array_func },
|
|
{}
|
|
};
|
|
static exprtab_t data_array_symtab = {
|
|
data_array_symbols,
|
|
};
|
|
|
|
static int
|
|
parse_specialization_data (const plitem_t *item, void **data,
|
|
plitem_t *messages, parsectx_t *pctx)
|
|
{
|
|
size_t *size_ptr = (size_t *) data[0];
|
|
void **data_ptr = (void **) data[1];
|
|
|
|
if (PL_Type (item) == QFBinary) {
|
|
const void *bindata = PL_BinaryData (item);
|
|
size_t binsize = PL_BinarySize (item);
|
|
|
|
*data_ptr = vkparse_alloc (pctx, binsize);
|
|
memcpy (*data_ptr, bindata, binsize);
|
|
*size_ptr = binsize;
|
|
return 1;
|
|
}
|
|
|
|
data_array_t *da= 0;
|
|
exprctx_t ectx = *pctx->ectx;
|
|
exprval_t result = { &data_array_type, &da };
|
|
ectx.parent = pctx->ectx;
|
|
ectx.symtab = &data_array_symtab;
|
|
ectx.result = &result;
|
|
ectx.item = item;
|
|
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;
|
|
//for (size_t i = 0; i < da->size; i++) {
|
|
// Sys_Printf (" %02x", da->a[i]);
|
|
//}
|
|
//Sys_Printf ("\n");
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
static int
|
|
parse_task_function (const plitem_t *item, void **data,
|
|
plitem_t *messages, parsectx_t *pctx)
|
|
{
|
|
qfv_renderctx_t *rctx = pctx->data;
|
|
const char *fname = PL_String (item);
|
|
exprsym_t *fsym = Hash_Find (rctx->task_functions.tab, fname);
|
|
|
|
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 *) ¶m_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] = ¶ms[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;
|
|
}
|
|
|
|
static int
|
|
parse_task_params (const plitem_t *item, void **data,
|
|
plitem_t *messages, parsectx_t *pctx)
|
|
{
|
|
exprfunc_t *func = *(exprfunc_t **) data[0];
|
|
exprval_t **params = *(exprval_t ***) data[1];
|
|
if (!func) {
|
|
PL_Message (messages, item, "task function not set");
|
|
return 0;
|
|
}
|
|
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;
|
|
}
|
|
|
|
#include "libs/video/renderer/vulkan/vkparse.cinc"
|
|
|
|
static exprsym_t qfv_renderframeset_t_symbols[] = {
|
|
{"size", &cexpr_size_t, (void *)field_offset (qfv_renderframeset_t, size)},
|
|
{ }
|
|
};
|
|
static exprtab_t qfv_renderframeset_t_symtab = {
|
|
qfv_renderframeset_t_symbols,
|
|
};
|
|
exprtype_t qfv_renderframeset_t_type = {
|
|
.name = "frameset",
|
|
.size = sizeof (qfv_renderframeset_t *),
|
|
.binops = cexpr_struct_binops,
|
|
.unops = 0,
|
|
.data = &qfv_renderframeset_t_symtab,
|
|
};
|
|
|
|
static hashtab_t *
|
|
handlref_symtab (void (*free_func)(void*,void*), scriptctx_t *sctx)
|
|
{
|
|
return Hash_NewTable (23, handleref_getkey, free_func, sctx,
|
|
&sctx->hashctx);
|
|
}
|
|
|
|
static const char *
|
|
enum_symtab_getkey (const void *e, void *unused)
|
|
{
|
|
__auto_type enm = (const exprenum_t *) e;
|
|
return enm->type->name;
|
|
}
|
|
|
|
static const char *
|
|
parser_getkey (const void *e, void *unused)
|
|
{
|
|
__auto_type parser = (const parserref_t *) e;
|
|
return parser->name;
|
|
}
|
|
|
|
static exprtab_t root_symtab = {
|
|
.symbols = cexpr_lib_symbols,
|
|
};
|
|
|
|
static void
|
|
root_symtab_shutdown (void *data)
|
|
{
|
|
Hash_DelTable (root_symtab.tab);
|
|
}
|
|
|
|
static void __attribute__((constructor))
|
|
root_symtab_init (void)
|
|
{
|
|
// using a null hashctx here is safe because this function is run before
|
|
// main and thus before any possibility of threading.
|
|
exprctx_t root_context = { .symtab = &root_symtab };
|
|
cexpr_init_symtab (&root_symtab, &root_context);
|
|
Sys_RegisterShutdown (root_symtab_shutdown, 0);
|
|
}
|
|
|
|
exprenum_t *
|
|
QFV_GetEnum (const char *name)
|
|
{
|
|
return Hash_Find (enum_symtab, name);
|
|
}
|
|
|
|
static int
|
|
parse_object (vulkan_ctx_t *ctx, memsuper_t *memsuper, plitem_t *plist,
|
|
plparser_t parser, void *object, plitem_t *properties)
|
|
{
|
|
scriptctx_t *sctx = ctx->script_context;
|
|
plitem_t *messages = PL_NewArray ();
|
|
exprctx_t exprctx = { .symtab = &root_symtab };
|
|
parsectx_t parsectx = { &exprctx, ctx, properties };
|
|
auto rctx = ctx->render_context;
|
|
exprsym_t var_syms[] = {
|
|
{"output", &qfv_output_t_type, &sctx->output},
|
|
{"frames", &qfv_renderframeset_t_type, &rctx->frames},
|
|
{"msaaSamples", &VkSampleCountFlagBits_type, &ctx->msaaSamples},
|
|
{"physDevLimits", &VkPhysicalDeviceLimits_type,
|
|
&ctx->device->physDev->properties->limits },
|
|
{QFV_PROPERTIES, &cexpr_plitem, &parsectx.properties},
|
|
{}
|
|
};
|
|
exprtab_t vars_tab = { var_syms, 0 };
|
|
|
|
exprctx.external_variables = &vars_tab;
|
|
exprctx.messages = messages;
|
|
exprctx.hashctx = &sctx->hashctx;
|
|
exprctx.memsuper = memsuper;
|
|
|
|
cexpr_init_symtab (&vars_tab, &exprctx);
|
|
|
|
|
|
if (!parser (0, plist, object, messages, &parsectx)) {
|
|
for (int i = 0; i < PL_A_NumObjects (messages); i++) {
|
|
Sys_Printf ("%s\n", PL_String (PL_ObjectAtIndex (messages, i)));
|
|
}
|
|
return 0;
|
|
}
|
|
Hash_DelTable (vars_tab.tab);
|
|
PL_Release (messages);
|
|
|
|
return 1;
|
|
}
|
|
|
|
VkRenderPass
|
|
QFV_ParseRenderPass (vulkan_ctx_t *ctx, plitem_t *plist, plitem_t *properties)
|
|
{
|
|
memsuper_t *memsuper = new_memsuper ();
|
|
qfv_device_t *device = ctx->device;
|
|
qfv_devfuncs_t *dfunc = device->funcs;
|
|
|
|
VkRenderPassCreateInfo cInfo = {};
|
|
|
|
if (!parse_object (ctx, memsuper, plist, parse_VkRenderPassCreateInfo,
|
|
&cInfo, properties)) {
|
|
delete_memsuper (memsuper);
|
|
return 0;
|
|
}
|
|
|
|
VkRenderPass renderpass;
|
|
qfvPushDebug (ctx, va (ctx->va_ctx, "QFV_ParseRenderPass: %d",
|
|
PL_Line (plist)));
|
|
dfunc->vkCreateRenderPass (device->dev, &cInfo, 0, &renderpass);
|
|
qfvPopDebug (ctx);
|
|
|
|
delete_memsuper (memsuper);
|
|
return renderpass;
|
|
}
|
|
|
|
VkPipeline
|
|
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)
|
|
{
|
|
memsuper_t *memsuper = new_memsuper ();
|
|
qfv_device_t *device = ctx->device;
|
|
|
|
__auto_type cInfo = QFV_AllocGraphicsPipelineCreateInfoSet (1, alloca);
|
|
memset (&cInfo->a[0], 0, sizeof (cInfo->a[0]));
|
|
|
|
if (!parse_object (ctx, memsuper, plist, parse_VkGraphicsPipelineCreateInfo,
|
|
&cInfo->a[0], properties)) {
|
|
delete_memsuper (memsuper);
|
|
return 0;
|
|
}
|
|
|
|
qfvPushDebug (ctx, va (ctx->va_ctx,
|
|
"QFV_ParsePipeline: %d", PL_Line (plist)));
|
|
|
|
__auto_type plSet = QFV_CreateGraphicsPipelines (device, 0, cInfo);
|
|
qfvPopDebug (ctx);
|
|
VkPipeline pipeline = plSet->a[0];
|
|
free (plSet);
|
|
delete_memsuper (memsuper);
|
|
return pipeline;
|
|
}
|
|
|
|
VkDescriptorPool
|
|
QFV_ParseDescriptorPool (vulkan_ctx_t *ctx, plitem_t *plist,
|
|
plitem_t *properties)
|
|
{
|
|
qfv_device_t *device = ctx->device;
|
|
qfv_devfuncs_t *dfunc = device->funcs;
|
|
memsuper_t *memsuper = new_memsuper ();
|
|
|
|
VkDescriptorPoolCreateInfo cInfo = {};
|
|
|
|
if (!parse_object (ctx, memsuper, plist, parse_VkDescriptorPoolCreateInfo,
|
|
&cInfo, properties)) {
|
|
delete_memsuper (memsuper);
|
|
return 0;
|
|
}
|
|
|
|
VkDescriptorPool pool;
|
|
qfvPushDebug (ctx, va (ctx->va_ctx, "QFV_ParseDescriptorPool: %d", PL_Line (plist)));
|
|
dfunc->vkCreateDescriptorPool (device->dev, &cInfo, 0, &pool);
|
|
qfvPopDebug (ctx);
|
|
|
|
delete_memsuper (memsuper);
|
|
return pool;
|
|
}
|
|
|
|
VkDescriptorSetLayout
|
|
QFV_ParseDescriptorSetLayout (vulkan_ctx_t *ctx, plitem_t *plist,
|
|
plitem_t *properties)
|
|
{
|
|
qfv_device_t *device = ctx->device;
|
|
qfv_devfuncs_t *dfunc = device->funcs;
|
|
memsuper_t *memsuper = new_memsuper ();
|
|
|
|
VkDescriptorSetLayoutCreateInfo cInfo = {};
|
|
|
|
if (!parse_object (ctx, memsuper, plist,
|
|
parse_VkDescriptorSetLayoutCreateInfo,
|
|
&cInfo, properties)) {
|
|
delete_memsuper (memsuper);
|
|
return 0;
|
|
}
|
|
|
|
VkDescriptorSetLayout setLayout;
|
|
qfvPushDebug (ctx, va (ctx->va_ctx, "QFV_ParseDescriptorSetLayout: %d", PL_Line (plist)));
|
|
dfunc->vkCreateDescriptorSetLayout (device->dev, &cInfo, 0, &setLayout);
|
|
QFV_duSetObjectName (device, VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT,
|
|
setLayout, va (ctx->va_ctx, "descriptorSetLayout:%d",
|
|
PL_Line (plist)));
|
|
qfvPopDebug (ctx);
|
|
|
|
delete_memsuper (memsuper);
|
|
return setLayout;
|
|
}
|
|
|
|
VkPipelineLayout
|
|
QFV_ParsePipelineLayout (vulkan_ctx_t *ctx, plitem_t *plist,
|
|
plitem_t *properties)
|
|
{
|
|
qfv_device_t *device = ctx->device;
|
|
qfv_devfuncs_t *dfunc = device->funcs;
|
|
memsuper_t *memsuper = new_memsuper ();
|
|
|
|
VkPipelineLayoutCreateInfo cInfo = {};
|
|
|
|
if (!parse_object (ctx, memsuper, plist, parse_VkPipelineLayoutCreateInfo,
|
|
&cInfo, properties)) {
|
|
delete_memsuper (memsuper);
|
|
return 0;
|
|
}
|
|
|
|
VkPipelineLayout layout;
|
|
qfvPushDebug (ctx, va (ctx->va_ctx, "QFV_ParsePipelineLayout: %d", PL_Line (plist)));
|
|
dfunc->vkCreatePipelineLayout (device->dev, &cInfo, 0, &layout);
|
|
QFV_duSetObjectName (device, VK_OBJECT_TYPE_PIPELINE_LAYOUT,
|
|
layout, va (ctx->va_ctx, "pipelineLayout:%d",
|
|
PL_Line (plist)));
|
|
qfvPopDebug (ctx);
|
|
|
|
delete_memsuper (memsuper);
|
|
return layout;
|
|
}
|
|
|
|
VkSampler
|
|
QFV_ParseSampler (vulkan_ctx_t *ctx, plitem_t *plist, plitem_t *properties)
|
|
{
|
|
qfv_device_t *device = ctx->device;
|
|
qfv_devfuncs_t *dfunc = device->funcs;
|
|
memsuper_t *memsuper = new_memsuper ();
|
|
|
|
VkSamplerCreateInfo cInfo = {};
|
|
|
|
if (!parse_object (ctx, memsuper, plist, parse_VkSamplerCreateInfo, &cInfo,
|
|
properties)) {
|
|
delete_memsuper (memsuper);
|
|
return 0;
|
|
}
|
|
|
|
VkSampler sampler;
|
|
qfvPushDebug (ctx, va (ctx->va_ctx, "QFV_ParseSampler: %d", PL_Line (plist)));
|
|
dfunc->vkCreateSampler (device->dev, &cInfo, 0, &sampler);
|
|
qfvPopDebug (ctx);
|
|
|
|
delete_memsuper (memsuper);
|
|
return sampler;
|
|
}
|
|
|
|
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;
|
|
memsuper_t *memsuper = new_memsuper ();
|
|
|
|
VkImageCreateInfo cInfo = {};
|
|
|
|
if (!parse_object (ctx, memsuper, plist, parse_VkImageCreateInfo, &cInfo,
|
|
properties)) {
|
|
delete_memsuper (memsuper);
|
|
return 0;
|
|
}
|
|
|
|
VkImage image;
|
|
qfvPushDebug (ctx, va (ctx->va_ctx, "QFV_ParseImage: %d", PL_Line (plist)));
|
|
dfunc->vkCreateImage (device->dev, &cInfo, 0, &image);
|
|
qfvPopDebug (ctx);
|
|
|
|
delete_memsuper (memsuper);
|
|
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;
|
|
memsuper_t *memsuper = new_memsuper ();
|
|
|
|
VkImageViewCreateInfo cInfo = {};
|
|
|
|
if (!parse_object (ctx, memsuper, plist, parse_VkImageViewCreateInfo,
|
|
&cInfo, properties)) {
|
|
delete_memsuper (memsuper);
|
|
return 0;
|
|
}
|
|
|
|
VkImageView imageView;
|
|
qfvPushDebug (ctx, va (ctx->va_ctx, "QFV_ParseImageView: %d", PL_Line (plist)));
|
|
dfunc->vkCreateImageView (device->dev, &cInfo, 0, &imageView);
|
|
qfvPopDebug (ctx);
|
|
|
|
delete_memsuper (memsuper);
|
|
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),
|
|
vkparse_alloc,
|
|
parse_VkImageCreateInfo,
|
|
};
|
|
|
|
static plelement_t qfv_imageviewcreate_dict = {
|
|
QFDictionary,
|
|
sizeof (VkImageViewCreateInfo),
|
|
vkparse_alloc,
|
|
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)
|
|
{
|
|
scriptctx_t *sctx = ctx->script_context;
|
|
qfv_device_t *device = ctx->device;
|
|
qfv_devfuncs_t *dfunc = device->funcs;
|
|
memsuper_t *memsuper = new_memsuper ();
|
|
|
|
imagecreate_t create = {};
|
|
|
|
pltype_t type = PL_Type (item);
|
|
|
|
if (type == QFDictionary) {
|
|
if (!parse_object (ctx, memsuper, item, parse_imagecreate_dict,
|
|
&create, properties)) {
|
|
delete_memsuper (memsuper);
|
|
return 0;
|
|
}
|
|
} else {
|
|
Sys_MaskPrintf (SYS_vulkan_parse, "Neither array nor dictionary: %d\n",
|
|
PL_Line (item));
|
|
delete_memsuper (memsuper);
|
|
return 0;
|
|
}
|
|
|
|
__auto_type set = QFV_AllocImages (create.count, malloc);
|
|
for (uint32_t i = 0; i < create.count; i++) {
|
|
qfvPushDebug (ctx, va (ctx->va_ctx, "QFV_ParseImageSet: %d", PL_Line (item)));
|
|
dfunc->vkCreateImage (device->dev, &create.info[i], 0, &set->a[i]);
|
|
|
|
const char *name = PL_KeyAtIndex (item, i);
|
|
QFV_duSetObjectName (device, VK_OBJECT_TYPE_IMAGE, set->a[i],
|
|
va (ctx->va_ctx, "image:%s", name));
|
|
qfvPopDebug (ctx);
|
|
name = resource_path (ctx, "images", name);
|
|
QFV_AddHandle (sctx->images, name, (uint64_t) set->a[i]);
|
|
}
|
|
|
|
delete_memsuper (memsuper);
|
|
return set;
|
|
}
|
|
|
|
qfv_imageviewset_t *
|
|
QFV_ParseImageViewSet (vulkan_ctx_t *ctx, plitem_t *item,
|
|
plitem_t *properties)
|
|
{
|
|
scriptctx_t *sctx = ctx->script_context;
|
|
qfv_device_t *device = ctx->device;
|
|
qfv_devfuncs_t *dfunc = device->funcs;
|
|
memsuper_t *memsuper = new_memsuper ();
|
|
|
|
imageviewcreate_t create = {};
|
|
|
|
pltype_t type = PL_Type (item);
|
|
|
|
if (type == QFDictionary) {
|
|
if (!parse_object (ctx, memsuper, item, parse_imageviewcreate_dict,
|
|
&create, properties)) {
|
|
delete_memsuper (memsuper);
|
|
return 0;
|
|
}
|
|
} else {
|
|
Sys_Printf ("Neither array nor dictionary: %d\n", PL_Line (item));
|
|
delete_memsuper (memsuper);
|
|
return 0;
|
|
}
|
|
|
|
__auto_type set = QFV_AllocImageViews (create.count, malloc);
|
|
for (uint32_t i = 0; i < create.count; i++) {
|
|
qfvPushDebug (ctx, va (ctx->va_ctx, "QFV_ParseImageViewSet: %d", PL_Line (item)));
|
|
dfunc->vkCreateImageView (device->dev, &create.info[i], 0, &set->a[i]);
|
|
qfvPopDebug (ctx);
|
|
|
|
const char *name = PL_KeyAtIndex (item, i);
|
|
name = resource_path (ctx, "imageViews", name);
|
|
QFV_AddHandle (sctx->imageViews, name, (uint64_t) set->a[i]);
|
|
}
|
|
|
|
delete_memsuper (memsuper);
|
|
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;
|
|
memsuper_t *memsuper = new_memsuper ();
|
|
|
|
VkFramebufferCreateInfo cInfo = {};
|
|
|
|
if (!parse_object (ctx, memsuper, plist, parse_VkFramebufferCreateInfo,
|
|
&cInfo, properties)) {
|
|
delete_memsuper (memsuper);
|
|
return 0;
|
|
}
|
|
|
|
VkFramebuffer framebuffer;
|
|
qfvPushDebug (ctx, va (ctx->va_ctx, "QFV_ParseFramebuffer: %d", PL_Line (plist)));
|
|
dfunc->vkCreateFramebuffer (device->dev, &cInfo, 0, &framebuffer);
|
|
qfvPopDebug (ctx);
|
|
Sys_MaskPrintf (SYS_vulkan_parse, "framebuffer, renderPass: %#zx, %#zx\n",
|
|
(size_t) framebuffer, (size_t) cInfo.renderPass);
|
|
|
|
delete_memsuper (memsuper);
|
|
return framebuffer;
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
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"
|
|
},
|
|
{ .name = "defcube",
|
|
.value = (void *)
|
|
#include "libs/video/renderer/vulkan/rp_defcube.plc"
|
|
},
|
|
{ .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"
|
|
},
|
|
{ .name = "main_def",
|
|
.value = (void *)
|
|
#include "libs/video/renderer/vulkan/rp_main_def.plc"
|
|
},
|
|
{ .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++) {
|
|
plitem_t *item = PL_GetDictionary (sym->value, &sctx->hashctx);
|
|
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);
|
|
}
|
|
|
|
static void
|
|
delete_configs (void)
|
|
{
|
|
int num_plists = 0;
|
|
for (exprsym_t *sym = builtin_plist_syms; sym->name; sym++) {
|
|
PL_Release (builtin_plists[num_plists]);
|
|
num_plists++;
|
|
}
|
|
free (builtin_plists);
|
|
}
|
|
|
|
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;
|
|
}
|
|
PL_Release (ectx.messages);
|
|
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);
|
|
//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;
|
|
vkgen_init_symtabs (&ectx);
|
|
cexpr_init_symtab (&qfv_output_t_symtab, &ectx);
|
|
cexpr_init_symtab (&qfv_renderframeset_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);
|
|
|
|
delete_configs ();
|
|
|
|
Hash_DelContext (sctx->hashctx);
|
|
|
|
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;
|
|
}
|
|
|
|
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;
|
|
|
|
if (extra_items) {
|
|
for (const char **e = extra_items; *e; e++) {
|
|
if (PL_ObjectForKey (dict, *e)) {
|
|
num_extra++;
|
|
}
|
|
}
|
|
}
|
|
if (extra_syms) {
|
|
for (exprsym_t *sym = extra_syms; sym->name; sym++, num_syms++) { }
|
|
}
|
|
|
|
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);
|
|
}
|
|
for (int i = 0, j = 0; num_extra && extra_items[i]; i++) {
|
|
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,
|
|
.value = items + num_keys + j,
|
|
};
|
|
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);
|
|
}
|
|
|
|
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[] = {
|
|
{"render_output", &qfv_output_t_type, &sctx->output},
|
|
{"frames", &qfv_renderframeset_t_type, &rctx->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)));
|
|
}
|
|
}
|
|
QFV_DestroySymtab (exprctx.external_variables);
|
|
PL_Release (messages);
|
|
if (!ret) {
|
|
delete_memsuper (memsuper);
|
|
ri = 0;
|
|
}
|
|
|
|
return ri;
|
|
}
|
|
|
|
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)));
|
|
}
|
|
}
|
|
PL_Release (messages);
|
|
PL_Release (item);
|
|
|
|
return ret;
|
|
}
|