qf/quakeforge
0
0
Fork 0
mirror of https://git.code.sf.net/p/quake/quakeforge synced 2025-06-02 09:31:12 +00:00
Code Issues Projects Releases Packages Wiki Activity

[qfcc] Redo interface blocks as namespaces

Browse source 
There's no direct support for namespaces in Ruamoko yet, nor even in
qfcc, but glsl's blocks bring in a bit of foundation for them, even the
concept of "using" (for blocks with no instance name).

The members don't get locations allocated to them yet, but
fstrianglest.vert compiles and links correctly otherwise.

Also, there's no error checking yet.
This commit is contained in:
Bill Currie 2024-08-31 01:15:07 +09:00
parent 291898b46f
commit 9b2b841a55
8 changed files with 197 additions and 23 deletions
Download patch file Download diff file Expand all files Collapse all files

143
tools/qfcc/source/glsl-block.c Normal file
View file

@ -0,0 +1,143 @@
/*
glsl-block.c
GLSL specific block handling
Copyright (C) 2024 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 "QF/alloc.h"
#include "QF/hash.h"
#include "QF/va.h"
#include "tools/qfcc/include/def.h"
#include "tools/qfcc/include/diagnostic.h"
#include "tools/qfcc/include/glsl-lang.h"
#include "tools/qfcc/include/shared.h"
#include "tools/qfcc/include/strpool.h"
#include "tools/qfcc/include/symtab.h"
ALLOC_STATE (glsl_block_t, blocks);
static hashtab_t *input_blocks;
static hashtab_t *output_blocks;
static hashtab_t *uniform_blocks;
static hashtab_t *buffer_blocks;
static hashtab_t *shared_blocks;
static const char *
block_get_key (const void *_b, void *)
{
auto b = (const glsl_block_t *) _b;
return b->name;
}
void
glsl_block_clear (void)
{
if (input_blocks) {
Hash_FlushTable (input_blocks);
Hash_FlushTable (output_blocks);
Hash_FlushTable (uniform_blocks);
Hash_FlushTable (buffer_blocks);
Hash_FlushTable (shared_blocks);
} else {
input_blocks = Hash_NewTable (127, block_get_key, 0, 0, 0);
output_blocks = Hash_NewTable (127, block_get_key, 0, 0, 0);
uniform_blocks = Hash_NewTable (127, block_get_key, 0, 0, 0);
buffer_blocks = Hash_NewTable (127, block_get_key, 0, 0, 0);
shared_blocks = Hash_NewTable (127, block_get_key, 0, 0, 0);
}
}
static const expr_t *
block_sym_ref (symbol_t *sym, void *data)
{
return new_symbol_expr (data);
}
void
glsl_declare_block (specifier_t spec, symbol_t *block_sym,
symbol_t *instance_name)
{
hashtab_t *block_tab = nullptr;
switch (spec.storage) {
case sc_in:
block_tab = input_blocks;
break;
case sc_out:
block_tab = output_blocks;
break;
case sc_uniform:
block_tab = uniform_blocks;
break;
case sc_buffer:
block_tab = buffer_blocks;
break;
case sc_shared:
block_tab = shared_blocks;
break;
case sc_global:
case sc_system:
case sc_extern:
case sc_static:
case sc_param:
case sc_local:
case sc_argument:
break;
}
if (!block_tab) {
error (0, "invalid storage for block");
return;
}
glsl_block_t *block;
ALLOC (64, glsl_block_t, blocks, block);
*block = (glsl_block_t) {
.name = save_string (block_sym->name),
.members = block_sym->namespace,
.instance_name = instance_name,
};
Hash_Add (block_tab, block);
for (auto sym = block->members->symbols; sym; sym = sym->next) {
auto def = new_def (sym->name, nullptr, nullptr, spec.storage);
def->type = sym->type;
sym->sy_type = sy_var;
sym->def = def;
}
if (instance_name) {
//namespace_add (instance_name, block->members);
} else {
for (auto sym = block->members->symbols; sym; sym = sym->next) {
auto new = new_symbol (sym->name);
new->sy_type = sy_convert;
new->convert = (symconv_t) {
.conv = block_sym_ref,
.data = sym,
};
symtab_addsymbol (current_symtab, new);
}
}
}