qf/quakeforge
0
0
Fork 0
mirror of https://git.code.sf.net/p/quake/quakeforge synced 2024-11-15 01:11:27 +00:00
Code Issues Projects Releases Packages Wiki Activity
quakeforge/libs/client/hud.c

292 lines
7.1 KiB
C
Raw Normal View History

[client] Merge nq and qw cl_view They've been near-identical for years, now they're only one. It proved necessary to start merging the HUD code which for now is just a few cvar declarations (not even init), but that should be a separate set of commits.
2022-02-28 03:12:51 +00:00
/*
hud.c
Heads-up display bar
Copyright (C) 1996-1997 Id Software, Inc.
Copyright (C) 2022 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
[cvar] Make cvars properly typed This is an extremely extensive patch as it hits every cvar, and every usage of the cvars. Cvars no longer store the value they control, instead, they use a cexpr value object to reference the value and specify the value's type (currently, a null type is used for strings). Non-string cvars are passed through cexpr, allowing expressions in the cvars' settings. Also, cvars have returned to an enhanced version of the original (id quake) registration scheme. As a minor benefit, relevant code having direct access to the cvar-controlled variables is probably a slight optimization as it removed a pointer dereference, and the variables can be located for data locality. The static cvar descriptors are made private as an additional safety layer, though there's nothing stopping external modification via Cvar_FindVar (which is needed for adding listeners). While not used yet (partly due to working out the design), cvars can have a validation function. Registering a cvar allows a primary listener (and its data) to be specified: it will always be called first when the cvar is modified. The combination of proper listeners and direct access to the controlled variable greatly simplifies the more complex cvar interactions as much less null checking is required, and there's no need for one cvar's callback to call another's. nq-x11 is known to work at least well enough for the demos. More testing will come.
2022-04-23 03:22:45 +00:00
#include <string.h>
[client] Merge nq and qw cl_view They've been near-identical for years, now they're only one. It proved necessary to start merging the HUD code which for now is just a few cvar declarations (not even init), but that should be a separate set of commits.
2022-02-28 03:12:51 +00:00
#include "QF/cvar.h"
[console] Move gib hud control into hud I don't know why it was ever in console.
2023-01-20 17:57:05 +00:00
#include "QF/gib.h"
[cvar] Make cvars properly typed This is an extremely extensive patch as it hits every cvar, and every usage of the cvars. Cvars no longer store the value they control, instead, they use a cexpr value object to reference the value and specify the value's type (currently, a null type is used for strings). Non-string cvars are passed through cexpr, allowing expressions in the cvars' settings. Also, cvars have returned to an enhanced version of the original (id quake) registration scheme. As a minor benefit, relevant code having direct access to the cvar-controlled variables is probably a slight optimization as it removed a pointer dereference, and the variables can be located for data locality. The static cvar descriptors are made private as an additional safety layer, though there's nothing stopping external modification via Cvar_FindVar (which is needed for adding listeners). While not used yet (partly due to working out the design), cvars can have a validation function. Registering a cvar allows a primary listener (and its data) to be specified: it will always be called first when the cvar is modified. The combination of proper listeners and direct access to the controlled variable greatly simplifies the more complex cvar interactions as much less null checking is required, and there's no need for one cvar's callback to call another's. nq-x11 is known to work at least well enough for the demos. More testing will come.
2022-04-23 03:22:45 +00:00
#include "QF/screen.h"
#include "QF/render.h"
#include "QF/plugin/vid_render.h"
[client] Switch to using canvases for screen and hud Canvases provide layered rendering as for each canvas all components are rendered in turn.
2023-01-20 18:34:33 +00:00
#include "QF/ui/canvas.h"
[ui] Add a component set for passage hierarchy refs While "set" is a tad strong (there's just the one component for now), I had missed the changes when adding ECS systems. Fixes the segfault at the end of demo1 (ie, when any center text is printed).
2022-12-16 09:12:38 +00:00
#include "QF/ui/passage.h"
[cvar] Make cvars properly typed This is an extremely extensive patch as it hits every cvar, and every usage of the cvars. Cvars no longer store the value they control, instead, they use a cexpr value object to reference the value and specify the value's type (currently, a null type is used for strings). Non-string cvars are passed through cexpr, allowing expressions in the cvars' settings. Also, cvars have returned to an enhanced version of the original (id quake) registration scheme. As a minor benefit, relevant code having direct access to the cvar-controlled variables is probably a slight optimization as it removed a pointer dereference, and the variables can be located for data locality. The static cvar descriptors are made private as an additional safety layer, though there's nothing stopping external modification via Cvar_FindVar (which is needed for adding listeners). While not used yet (partly due to working out the design), cvars can have a validation function. Registering a cvar allows a primary listener (and its data) to be specified: it will always be called first when the cvar is modified. The combination of proper listeners and direct access to the controlled variable greatly simplifies the more complex cvar interactions as much less null checking is required, and there's no need for one cvar's callback to call another's. nq-x11 is known to work at least well enough for the demos. More testing will come.
2022-04-23 03:22:45 +00:00
#include "QF/ui/view.h"
#include "compat.h"
#include "client/hud.h"
[client] Switch to using canvases for screen and hud Canvases provide layered rendering as for each canvas all components are rendered in turn.
2023-01-20 18:34:33 +00:00
#include "client/screen.h"
[cvar] Make cvars properly typed This is an extremely extensive patch as it hits every cvar, and every usage of the cvars. Cvars no longer store the value they control, instead, they use a cexpr value object to reference the value and specify the value's type (currently, a null type is used for strings). Non-string cvars are passed through cexpr, allowing expressions in the cvars' settings. Also, cvars have returned to an enhanced version of the original (id quake) registration scheme. As a minor benefit, relevant code having direct access to the cvar-controlled variables is probably a slight optimization as it removed a pointer dereference, and the variables can be located for data locality. The static cvar descriptors are made private as an additional safety layer, though there's nothing stopping external modification via Cvar_FindVar (which is needed for adding listeners). While not used yet (partly due to working out the design), cvars can have a validation function. Registering a cvar allows a primary listener (and its data) to be specified: it will always be called first when the cvar is modified. The combination of proper listeners and direct access to the controlled variable greatly simplifies the more complex cvar interactions as much less null checking is required, and there's no need for one cvar's callback to call another's. nq-x11 is known to work at least well enough for the demos. More testing will come.
2022-04-23 03:22:45 +00:00
[ui] Add a component set for passage hierarchy refs While "set" is a tad strong (there's just the one component for now), I had missed the changes when adding ECS systems. Fixes the segfault at the end of demo1 (ie, when any center text is printed).
2022-12-16 09:12:38 +00:00
ecs_system_t hud_psgsys;
[client] Switch to using canvases for screen and hud Canvases provide layered rendering as for each canvas all components are rendered in turn.
2023-01-20 18:34:33 +00:00
uint32_t hud_canvas;
[cvar] Make cvars properly typed This is an extremely extensive patch as it hits every cvar, and every usage of the cvars. Cvars no longer store the value they control, instead, they use a cexpr value object to reference the value and specify the value's type (currently, a null type is used for strings). Non-string cvars are passed through cexpr, allowing expressions in the cvars' settings. Also, cvars have returned to an enhanced version of the original (id quake) registration scheme. As a minor benefit, relevant code having direct access to the cvar-controlled variables is probably a slight optimization as it removed a pointer dereference, and the variables can be located for data locality. The static cvar descriptors are made private as an additional safety layer, though there's nothing stopping external modification via Cvar_FindVar (which is needed for adding listeners). While not used yet (partly due to working out the design), cvars can have a validation function. Registering a cvar allows a primary listener (and its data) to be specified: it will always be called first when the cvar is modified. The combination of proper listeners and direct access to the controlled variable greatly simplifies the more complex cvar interactions as much less null checking is required, and there's no need for one cvar's callback to call another's. nq-x11 is known to work at least well enough for the demos. More testing will come.
2022-04-23 03:22:45 +00:00
int hud_sb_lines;
int hud_sbar;
static cvar_t hud_sbar_cvar = {
.name = "hud_sbar",
.description =
"status bar mode: 0 = hud, 1 = oldstyle",
.default_value = "0",
.flags = CVAR_ARCHIVE,
.value = { .type = &cexpr_int, .value = &hud_sbar },
};
[client] Switch to using canvases for screen and hud Canvases provide layered rendering as for each canvas all components are rendered in turn.
2023-01-20 18:34:33 +00:00
grav_t hud_scoreboard_gravity = grav_center;
#if 0
[cvar] Make cvars properly typed This is an extremely extensive patch as it hits every cvar, and every usage of the cvars. Cvars no longer store the value they control, instead, they use a cexpr value object to reference the value and specify the value's type (currently, a null type is used for strings). Non-string cvars are passed through cexpr, allowing expressions in the cvars' settings. Also, cvars have returned to an enhanced version of the original (id quake) registration scheme. As a minor benefit, relevant code having direct access to the cvar-controlled variables is probably a slight optimization as it removed a pointer dereference, and the variables can be located for data locality. The static cvar descriptors are made private as an additional safety layer, though there's nothing stopping external modification via Cvar_FindVar (which is needed for adding listeners). While not used yet (partly due to working out the design), cvars can have a validation function. Registering a cvar allows a primary listener (and its data) to be specified: it will always be called first when the cvar is modified. The combination of proper listeners and direct access to the controlled variable greatly simplifies the more complex cvar interactions as much less null checking is required, and there's no need for one cvar's callback to call another's. nq-x11 is known to work at least well enough for the demos. More testing will come.
2022-04-23 03:22:45 +00:00
static cvar_t hud_scoreboard_gravity_cvar = {
.name = "hud_scoreboard_gravity",
.description =
"control placement of scoreboard overlay: center, northwest, north, "
"northeast, west, east, southwest, south, southeast",
.default_value = "center",
.flags = CVAR_ARCHIVE,
[view] Add a cexpr enum for grav_t And use it for hud_scoreboard_gravity. Putting the enum def in view made the most sense as view does own the base type and the enum is likely to be by useful for other settings.
2022-04-24 12:09:58 +00:00
.value = { .type = &grav_t_type, .value = &hud_scoreboard_gravity },
[cvar] Make cvars properly typed This is an extremely extensive patch as it hits every cvar, and every usage of the cvars. Cvars no longer store the value they control, instead, they use a cexpr value object to reference the value and specify the value's type (currently, a null type is used for strings). Non-string cvars are passed through cexpr, allowing expressions in the cvars' settings. Also, cvars have returned to an enhanced version of the original (id quake) registration scheme. As a minor benefit, relevant code having direct access to the cvar-controlled variables is probably a slight optimization as it removed a pointer dereference, and the variables can be located for data locality. The static cvar descriptors are made private as an additional safety layer, though there's nothing stopping external modification via Cvar_FindVar (which is needed for adding listeners). While not used yet (partly due to working out the design), cvars can have a validation function. Registering a cvar allows a primary listener (and its data) to be specified: it will always be called first when the cvar is modified. The combination of proper listeners and direct access to the controlled variable greatly simplifies the more complex cvar interactions as much less null checking is required, and there's no need for one cvar's callback to call another's. nq-x11 is known to work at least well enough for the demos. More testing will come.
2022-04-23 03:22:45 +00:00
};
[client] Switch to using canvases for screen and hud Canvases provide layered rendering as for each canvas all components are rendered in turn.
2023-01-20 18:34:33 +00:00
#endif
[cvar] Make cvars properly typed This is an extremely extensive patch as it hits every cvar, and every usage of the cvars. Cvars no longer store the value they control, instead, they use a cexpr value object to reference the value and specify the value's type (currently, a null type is used for strings). Non-string cvars are passed through cexpr, allowing expressions in the cvars' settings. Also, cvars have returned to an enhanced version of the original (id quake) registration scheme. As a minor benefit, relevant code having direct access to the cvar-controlled variables is probably a slight optimization as it removed a pointer dereference, and the variables can be located for data locality. The static cvar descriptors are made private as an additional safety layer, though there's nothing stopping external modification via Cvar_FindVar (which is needed for adding listeners). While not used yet (partly due to working out the design), cvars can have a validation function. Registering a cvar allows a primary listener (and its data) to be specified: it will always be called first when the cvar is modified. The combination of proper listeners and direct access to the controlled variable greatly simplifies the more complex cvar interactions as much less null checking is required, and there's no need for one cvar's callback to call another's. nq-x11 is known to work at least well enough for the demos. More testing will come.
2022-04-23 03:22:45 +00:00
int hud_swap;
static cvar_t hud_swap_cvar = {
.name = "hud_swap",
.description =
"new HUD on left side?",
.default_value = "0",
.flags = CVAR_ARCHIVE,
.value = { .type = &cexpr_int, .value = &hud_swap },
};
[nq] Get hud time and fps displays working This includes moving the related cvars from botn nq and qw into the client hud code. In addition, the hud code supports update and update-once function components. The update component is for updates that occur every frame, but update-once components (not used yet) are for one-shot updates (eg, when a value updates very infrequently).
2022-11-03 05:46:44 +00:00
int hud_fps;
static cvar_t hud_fps_cvar = {
.name = "hud_fps",
.description =
"display realtime frames per second",
.default_value = "0",
.flags = CVAR_ARCHIVE,
.value = { .type = &cexpr_int, .value = &hud_fps },
};
int hud_ping;
static cvar_t hud_ping_cvar = {
.name = "hud_ping",
.description =
"display current ping to server",
.default_value = "0",
.flags = CVAR_ARCHIVE,
.value = { .type = &cexpr_int, .value = &hud_ping },
};
int hud_pl;
static cvar_t hud_pl_cvar = {
.name = "hud_pl",
.description =
"display current packet loss to server",
.default_value = "0",
.flags = CVAR_ARCHIVE,
.value = { .type = &cexpr_int, .value = &hud_pl },
};
int hud_time;
static cvar_t hud_time_cvar = {
.name = "hud_time",
.description =
"display the current time",
.default_value = "0",
.flags = CVAR_ARCHIVE,
.value = { .type = &cexpr_int, .value = &hud_time },
};
[client] Add hud_debug cvar to draw view outlines It's much easier to debug the hud when even otherwise invisible views can be seen.
2022-11-05 07:38:07 +00:00
int hud_debug;
static cvar_t hud_debug_cvar = {
.name = "hud_debug",
.description =
"display hud view outlines for debugging",
.default_value = "0",
.flags = CVAR_NONE,
.value = { .type = &cexpr_int, .value = &hud_debug },
};
[cvar] Make cvars properly typed This is an extremely extensive patch as it hits every cvar, and every usage of the cvars. Cvars no longer store the value they control, instead, they use a cexpr value object to reference the value and specify the value's type (currently, a null type is used for strings). Non-string cvars are passed through cexpr, allowing expressions in the cvars' settings. Also, cvars have returned to an enhanced version of the original (id quake) registration scheme. As a minor benefit, relevant code having direct access to the cvar-controlled variables is probably a slight optimization as it removed a pointer dereference, and the variables can be located for data locality. The static cvar descriptors are made private as an additional safety layer, though there's nothing stopping external modification via Cvar_FindVar (which is needed for adding listeners). While not used yet (partly due to working out the design), cvars can have a validation function. Registering a cvar allows a primary listener (and its data) to be specified: it will always be called first when the cvar is modified. The combination of proper listeners and direct access to the controlled variable greatly simplifies the more complex cvar interactions as much less null checking is required, and there's no need for one cvar's callback to call another's. nq-x11 is known to work at least well enough for the demos. More testing will come.
2022-04-23 03:22:45 +00:00
[client] Switch to using canvases for screen and hud Canvases provide layered rendering as for each canvas all components are rendered in turn.
2023-01-20 18:34:33 +00:00
view_t hud_canvas_view;
[client] Add hud_debug cvar to draw view outlines It's much easier to debug the hud when even otherwise invisible views can be seen.
2022-11-05 07:38:07 +00:00
static void
[client] Switch to using canvases for screen and hud Canvases provide layered rendering as for each canvas all components are rendered in turn.
2023-01-20 18:34:33 +00:00
hud_add_outlines (view_t view, byte color)
[client] Add hud_debug cvar to draw view outlines It's much easier to debug the hud when even otherwise invisible views can be seen.
2022-11-05 07:38:07 +00:00
{
[client] Switch to using canvases for screen and hud Canvases provide layered rendering as for each canvas all components are rendered in turn.
2023-01-20 18:34:33 +00:00
Ent_SetComponent (view.id, canvas_outline, view.reg, &color);
[client] Add hud_debug cvar to draw view outlines It's much easier to debug the hud when even otherwise invisible views can be seen.
2022-11-05 07:38:07 +00:00
uint32_t count = View_ChildCount (view);
for (uint32_t i = 0; i < count; i++) {
[client] Switch to using canvases for screen and hud Canvases provide layered rendering as for each canvas all components are rendered in turn.
2023-01-20 18:34:33 +00:00
hud_add_outlines (View_GetChild (view, i), color);
[client] Add hud_debug cvar to draw view outlines It's much easier to debug the hud when even otherwise invisible views can be seen.
2022-11-05 07:38:07 +00:00
}
}
static void
hud_remove_outlines (view_t view)
{
[client] Switch to using canvases for screen and hud Canvases provide layered rendering as for each canvas all components are rendered in turn.
2023-01-20 18:34:33 +00:00
Ent_RemoveComponent (view.id, canvas_outline, view.reg);
[client] Add hud_debug cvar to draw view outlines It's much easier to debug the hud when even otherwise invisible views can be seen.
2022-11-05 07:38:07 +00:00
uint32_t count = View_ChildCount (view);
for (uint32_t i = 0; i < count; i++) {
hud_remove_outlines (View_GetChild (view, i));
}
}
static void
hud_debug_f (void *data, const cvar_t *cvar)
{
[client] Switch to using canvases for screen and hud Canvases provide layered rendering as for each canvas all components are rendered in turn.
2023-01-20 18:34:33 +00:00
if (!View_Valid (hud_canvas_view)) {
[client] Add hud_debug cvar to draw view outlines It's much easier to debug the hud when even otherwise invisible views can be seen.
2022-11-05 07:38:07 +00:00
return;
}
if (hud_debug) {
[client] Switch to using canvases for screen and hud Canvases provide layered rendering as for each canvas all components are rendered in turn.
2023-01-20 18:34:33 +00:00
hud_add_outlines (hud_canvas_view, 0x6f);
[client] Add hud_debug cvar to draw view outlines It's much easier to debug the hud when even otherwise invisible views can be seen.
2022-11-05 07:38:07 +00:00
} else {
[client] Switch to using canvases for screen and hud Canvases provide layered rendering as for each canvas all components are rendered in turn.
2023-01-20 18:34:33 +00:00
hud_remove_outlines (hud_canvas_view);
[client] Add hud_debug cvar to draw view outlines It's much easier to debug the hud when even otherwise invisible views can be seen.
2022-11-05 07:38:07 +00:00
}
}
[cvar] Make cvars properly typed This is an extremely extensive patch as it hits every cvar, and every usage of the cvars. Cvars no longer store the value they control, instead, they use a cexpr value object to reference the value and specify the value's type (currently, a null type is used for strings). Non-string cvars are passed through cexpr, allowing expressions in the cvars' settings. Also, cvars have returned to an enhanced version of the original (id quake) registration scheme. As a minor benefit, relevant code having direct access to the cvar-controlled variables is probably a slight optimization as it removed a pointer dereference, and the variables can be located for data locality. The static cvar descriptors are made private as an additional safety layer, though there's nothing stopping external modification via Cvar_FindVar (which is needed for adding listeners). While not used yet (partly due to working out the design), cvars can have a validation function. Registering a cvar allows a primary listener (and its data) to be specified: it will always be called first when the cvar is modified. The combination of proper listeners and direct access to the controlled variable greatly simplifies the more complex cvar interactions as much less null checking is required, and there's no need for one cvar's callback to call another's. nq-x11 is known to work at least well enough for the demos. More testing will come.
2022-04-23 03:22:45 +00:00
static void
hud_sbar_f (void *data, const cvar_t *cvar)
{
HUD_Calc_sb_lines (*r_data->scr_viewsize);
SCR_SetBottomMargin (hud_sbar ? hud_sb_lines : 0);
[ui] Convert view_t to an ECS entity Much of the nq/qw HUD system is quite broken, but the basic status bar seems to be working nicely. As is the console (both client and server). Possibly the biggest benefit is separating the rendering of HUD elements from the updating of them, and much less traversing of invisible views whose only purpose is to control the positioning of the visible views. The view flow tests are currently disabled until I adapt the flow code to ECS. There seems to be a problem with view resizing in that some gravities don't follow resizing correctly.
2022-10-31 15:40:52 +00:00
#if 0//XXX
[cvar] Make cvars properly typed This is an extremely extensive patch as it hits every cvar, and every usage of the cvars. Cvars no longer store the value they control, instead, they use a cexpr value object to reference the value and specify the value's type (currently, a null type is used for strings). Non-string cvars are passed through cexpr, allowing expressions in the cvars' settings. Also, cvars have returned to an enhanced version of the original (id quake) registration scheme. As a minor benefit, relevant code having direct access to the cvar-controlled variables is probably a slight optimization as it removed a pointer dereference, and the variables can be located for data locality. The static cvar descriptors are made private as an additional safety layer, though there's nothing stopping external modification via Cvar_FindVar (which is needed for adding listeners). While not used yet (partly due to working out the design), cvars can have a validation function. Registering a cvar allows a primary listener (and its data) to be specified: it will always be called first when the cvar is modified. The combination of proper listeners and direct access to the controlled variable greatly simplifies the more complex cvar interactions as much less null checking is required, and there's no need for one cvar's callback to call another's. nq-x11 is known to work at least well enough for the demos. More testing will come.
2022-04-23 03:22:45 +00:00
if (hud_sbar) {
view_remove (hud_main_view, hud_main_view->children[0]);
} else {
view_remove (hud_main_view, hud_main_view->children[0]);
[client] Switch to using canvases for screen and hud Canvases provide layered rendering as for each canvas all components are rendered in turn.
2023-01-20 18:34:33 +00:00
view_insert (hud_main_view, hud_canvas_view, 0);
[cvar] Make cvars properly typed This is an extremely extensive patch as it hits every cvar, and every usage of the cvars. Cvars no longer store the value they control, instead, they use a cexpr value object to reference the value and specify the value's type (currently, a null type is used for strings). Non-string cvars are passed through cexpr, allowing expressions in the cvars' settings. Also, cvars have returned to an enhanced version of the original (id quake) registration scheme. As a minor benefit, relevant code having direct access to the cvar-controlled variables is probably a slight optimization as it removed a pointer dereference, and the variables can be located for data locality. The static cvar descriptors are made private as an additional safety layer, though there's nothing stopping external modification via Cvar_FindVar (which is needed for adding listeners). While not used yet (partly due to working out the design), cvars can have a validation function. Registering a cvar allows a primary listener (and its data) to be specified: it will always be called first when the cvar is modified. The combination of proper listeners and direct access to the controlled variable greatly simplifies the more complex cvar interactions as much less null checking is required, and there's no need for one cvar's callback to call another's. nq-x11 is known to work at least well enough for the demos. More testing will come.
2022-04-23 03:22:45 +00:00
}
[ui] Convert view_t to an ECS entity Much of the nq/qw HUD system is quite broken, but the basic status bar seems to be working nicely. As is the console (both client and server). Possibly the biggest benefit is separating the rendering of HUD elements from the updating of them, and much less traversing of invisible views whose only purpose is to control the positioning of the visible views. The view flow tests are currently disabled until I adapt the flow code to ECS. There seems to be a problem with view resizing in that some gravities don't follow resizing correctly.
2022-10-31 15:40:52 +00:00
#endif
[cvar] Make cvars properly typed This is an extremely extensive patch as it hits every cvar, and every usage of the cvars. Cvars no longer store the value they control, instead, they use a cexpr value object to reference the value and specify the value's type (currently, a null type is used for strings). Non-string cvars are passed through cexpr, allowing expressions in the cvars' settings. Also, cvars have returned to an enhanced version of the original (id quake) registration scheme. As a minor benefit, relevant code having direct access to the cvar-controlled variables is probably a slight optimization as it removed a pointer dereference, and the variables can be located for data locality. The static cvar descriptors are made private as an additional safety layer, though there's nothing stopping external modification via Cvar_FindVar (which is needed for adding listeners). While not used yet (partly due to working out the design), cvars can have a validation function. Registering a cvar allows a primary listener (and its data) to be specified: it will always be called first when the cvar is modified. The combination of proper listeners and direct access to the controlled variable greatly simplifies the more complex cvar interactions as much less null checking is required, and there's no need for one cvar's callback to call another's. nq-x11 is known to work at least well enough for the demos. More testing will come.
2022-04-23 03:22:45 +00:00
}
static void
hud_swap_f (void *data, const cvar_t *cvar)
{
[ui] Convert view_t to an ECS entity Much of the nq/qw HUD system is quite broken, but the basic status bar seems to be working nicely. As is the console (both client and server). Possibly the biggest benefit is separating the rendering of HUD elements from the updating of them, and much less traversing of invisible views whose only purpose is to control the positioning of the visible views. The view flow tests are currently disabled until I adapt the flow code to ECS. There seems to be a problem with view resizing in that some gravities don't follow resizing correctly.
2022-10-31 15:40:52 +00:00
#if 0//XXX
[cvar] Make cvars properly typed This is an extremely extensive patch as it hits every cvar, and every usage of the cvars. Cvars no longer store the value they control, instead, they use a cexpr value object to reference the value and specify the value's type (currently, a null type is used for strings). Non-string cvars are passed through cexpr, allowing expressions in the cvars' settings. Also, cvars have returned to an enhanced version of the original (id quake) registration scheme. As a minor benefit, relevant code having direct access to the cvar-controlled variables is probably a slight optimization as it removed a pointer dereference, and the variables can be located for data locality. The static cvar descriptors are made private as an additional safety layer, though there's nothing stopping external modification via Cvar_FindVar (which is needed for adding listeners). While not used yet (partly due to working out the design), cvars can have a validation function. Registering a cvar allows a primary listener (and its data) to be specified: it will always be called first when the cvar is modified. The combination of proper listeners and direct access to the controlled variable greatly simplifies the more complex cvar interactions as much less null checking is required, and there's no need for one cvar's callback to call another's. nq-x11 is known to work at least well enough for the demos. More testing will come.
2022-04-23 03:22:45 +00:00
if (hud_swap) {
//FIXME why is this needed for nq but not for qw?
hud_armament_view->children[0]->gravity = grav_northwest;
hud_armament_view->children[1]->gravity = grav_southeast;
view_setgravity (hud_armament_view, grav_southwest);
view_setgravity (hud_stuff_view, grav_southeast);
} else {
//FIXME why is this needed for nq but not for qw?
hud_armament_view->children[0]->gravity = grav_northeast;
hud_armament_view->children[1]->gravity = grav_southwest;
view_setgravity (hud_armament_view, grav_southeast);
view_setgravity (hud_stuff_view, grav_southwest);
}
view_move (hud_armament_view, hud_armament_view->xpos,
hud_armament_view->ypos);
view_move (hud_stuff_view, hud_stuff_view->xpos, hud_stuff_view->ypos);
[ui] Convert view_t to an ECS entity Much of the nq/qw HUD system is quite broken, but the basic status bar seems to be working nicely. As is the console (both client and server). Possibly the biggest benefit is separating the rendering of HUD elements from the updating of them, and much less traversing of invisible views whose only purpose is to control the positioning of the visible views. The view flow tests are currently disabled until I adapt the flow code to ECS. There seems to be a problem with view resizing in that some gravities don't follow resizing correctly.
2022-10-31 15:40:52 +00:00
#endif
[cvar] Make cvars properly typed This is an extremely extensive patch as it hits every cvar, and every usage of the cvars. Cvars no longer store the value they control, instead, they use a cexpr value object to reference the value and specify the value's type (currently, a null type is used for strings). Non-string cvars are passed through cexpr, allowing expressions in the cvars' settings. Also, cvars have returned to an enhanced version of the original (id quake) registration scheme. As a minor benefit, relevant code having direct access to the cvar-controlled variables is probably a slight optimization as it removed a pointer dereference, and the variables can be located for data locality. The static cvar descriptors are made private as an additional safety layer, though there's nothing stopping external modification via Cvar_FindVar (which is needed for adding listeners). While not used yet (partly due to working out the design), cvars can have a validation function. Registering a cvar allows a primary listener (and its data) to be specified: it will always be called first when the cvar is modified. The combination of proper listeners and direct access to the controlled variable greatly simplifies the more complex cvar interactions as much less null checking is required, and there's no need for one cvar's callback to call another's. nq-x11 is known to work at least well enough for the demos. More testing will come.
2022-04-23 03:22:45 +00:00
}
[client] Switch to using canvases for screen and hud Canvases provide layered rendering as for each canvas all components are rendered in turn.
2023-01-20 18:34:33 +00:00
#if 0
[cvar] Make cvars properly typed This is an extremely extensive patch as it hits every cvar, and every usage of the cvars. Cvars no longer store the value they control, instead, they use a cexpr value object to reference the value and specify the value's type (currently, a null type is used for strings). Non-string cvars are passed through cexpr, allowing expressions in the cvars' settings. Also, cvars have returned to an enhanced version of the original (id quake) registration scheme. As a minor benefit, relevant code having direct access to the cvar-controlled variables is probably a slight optimization as it removed a pointer dereference, and the variables can be located for data locality. The static cvar descriptors are made private as an additional safety layer, though there's nothing stopping external modification via Cvar_FindVar (which is needed for adding listeners). While not used yet (partly due to working out the design), cvars can have a validation function. Registering a cvar allows a primary listener (and its data) to be specified: it will always be called first when the cvar is modified. The combination of proper listeners and direct access to the controlled variable greatly simplifies the more complex cvar interactions as much less null checking is required, and there's no need for one cvar's callback to call another's. nq-x11 is known to work at least well enough for the demos. More testing will come.
2022-04-23 03:22:45 +00:00
static void
hud_scoreboard_gravity_f (void *data, const cvar_t *cvar)
{
[nq] Get intermission view working again This is currently just the basic intermission view (not the finale view or the deathmatch intermission view).
2022-11-03 08:49:05 +00:00
if (View_Valid (hud_overlay_view)) {
View_SetGravity (hud_overlay_view, hud_scoreboard_gravity);
}
[ui] Convert view_t to an ECS entity Much of the nq/qw HUD system is quite broken, but the basic status bar seems to be working nicely. As is the console (both client and server). Possibly the biggest benefit is separating the rendering of HUD elements from the updating of them, and much less traversing of invisible views whose only purpose is to control the positioning of the visible views. The view flow tests are currently disabled until I adapt the flow code to ECS. There seems to be a problem with view resizing in that some gravities don't follow resizing correctly.
2022-10-31 15:40:52 +00:00
}
[client] Switch to using canvases for screen and hud Canvases provide layered rendering as for each canvas all components are rendered in turn.
2023-01-20 18:34:33 +00:00
#endif
[console] Move gib hud control into hud I don't know why it was ever in console.
2023-01-20 17:57:05 +00:00
static void
C_GIB_HUD_Enable_f (void)
{
//hud_canvas_view->visible = 1;
}
static void
C_GIB_HUD_Disable_f (void)
{
//hud_canvas_view->visible = 0;
}
[ui] Convert view_t to an ECS entity Much of the nq/qw HUD system is quite broken, but the basic status bar seems to be working nicely. As is the console (both client and server). Possibly the biggest benefit is separating the rendering of HUD elements from the updating of them, and much less traversing of invisible views whose only purpose is to control the positioning of the visible views. The view flow tests are currently disabled until I adapt the flow code to ECS. There seems to be a problem with view resizing in that some gravities don't follow resizing correctly.
2022-10-31 15:40:52 +00:00
void
[client] Switch to using canvases for screen and hud Canvases provide layered rendering as for each canvas all components are rendered in turn.
2023-01-20 18:34:33 +00:00
HUD_Init (ecs_registry_t *reg)
[ui] Convert view_t to an ECS entity Much of the nq/qw HUD system is quite broken, but the basic status bar seems to be working nicely. As is the console (both client and server). Possibly the biggest benefit is separating the rendering of HUD elements from the updating of them, and much less traversing of invisible views whose only purpose is to control the positioning of the visible views. The view flow tests are currently disabled until I adapt the flow code to ECS. There seems to be a problem with view resizing in that some gravities don't follow resizing correctly.
2022-10-31 15:40:52 +00:00
{
[client] Switch to using canvases for screen and hud Canvases provide layered rendering as for each canvas all components are rendered in turn.
2023-01-20 18:34:33 +00:00
hud_psgsys = (ecs_system_t) {
.reg = reg,
.base = ECS_RegisterComponents (reg, passage_components,
passage_comp_count),
};
[console] Move gib hud control into hud I don't know why it was ever in console.
2023-01-20 17:57:05 +00:00
// register GIB builtins
GIB_Builtin_Add ("HUD::enable", C_GIB_HUD_Enable_f);
GIB_Builtin_Add ("HUD::disable", C_GIB_HUD_Disable_f);
[cvar] Make cvars properly typed This is an extremely extensive patch as it hits every cvar, and every usage of the cvars. Cvars no longer store the value they control, instead, they use a cexpr value object to reference the value and specify the value's type (currently, a null type is used for strings). Non-string cvars are passed through cexpr, allowing expressions in the cvars' settings. Also, cvars have returned to an enhanced version of the original (id quake) registration scheme. As a minor benefit, relevant code having direct access to the cvar-controlled variables is probably a slight optimization as it removed a pointer dereference, and the variables can be located for data locality. The static cvar descriptors are made private as an additional safety layer, though there's nothing stopping external modification via Cvar_FindVar (which is needed for adding listeners). While not used yet (partly due to working out the design), cvars can have a validation function. Registering a cvar allows a primary listener (and its data) to be specified: it will always be called first when the cvar is modified. The combination of proper listeners and direct access to the controlled variable greatly simplifies the more complex cvar interactions as much less null checking is required, and there's no need for one cvar's callback to call another's. nq-x11 is known to work at least well enough for the demos. More testing will come.
2022-04-23 03:22:45 +00:00
}
void
HUD_Init_Cvars (void)
{
[nq] Get hud time and fps displays working This includes moving the related cvars from botn nq and qw into the client hud code. In addition, the hud code supports update and update-once function components. The update component is for updates that occur every frame, but update-once components (not used yet) are for one-shot updates (eg, when a value updates very infrequently).
2022-11-03 05:46:44 +00:00
Cvar_Register (&hud_fps_cvar, 0, 0);
Cvar_MakeAlias ("show_fps", &hud_fps_cvar);
Cvar_Register (&hud_ping_cvar, 0, 0);
Cvar_Register (&hud_pl_cvar, 0, 0);
Cvar_Register (&hud_time_cvar, 0, 0);
[client] Add hud_debug cvar to draw view outlines It's much easier to debug the hud when even otherwise invisible views can be seen.
2022-11-05 07:38:07 +00:00
Cvar_Register (&hud_debug_cvar, hud_debug_f, 0);
[nq] Get hud time and fps displays working This includes moving the related cvars from botn nq and qw into the client hud code. In addition, the hud code supports update and update-once function components. The update component is for updates that occur every frame, but update-once components (not used yet) are for one-shot updates (eg, when a value updates very infrequently).
2022-11-03 05:46:44 +00:00
[cvar] Make cvars properly typed This is an extremely extensive patch as it hits every cvar, and every usage of the cvars. Cvars no longer store the value they control, instead, they use a cexpr value object to reference the value and specify the value's type (currently, a null type is used for strings). Non-string cvars are passed through cexpr, allowing expressions in the cvars' settings. Also, cvars have returned to an enhanced version of the original (id quake) registration scheme. As a minor benefit, relevant code having direct access to the cvar-controlled variables is probably a slight optimization as it removed a pointer dereference, and the variables can be located for data locality. The static cvar descriptors are made private as an additional safety layer, though there's nothing stopping external modification via Cvar_FindVar (which is needed for adding listeners). While not used yet (partly due to working out the design), cvars can have a validation function. Registering a cvar allows a primary listener (and its data) to be specified: it will always be called first when the cvar is modified. The combination of proper listeners and direct access to the controlled variable greatly simplifies the more complex cvar interactions as much less null checking is required, and there's no need for one cvar's callback to call another's. nq-x11 is known to work at least well enough for the demos. More testing will come.
2022-04-23 03:22:45 +00:00
Cvar_Register (&hud_sbar_cvar, hud_sbar_f, 0);
Cvar_Register (&hud_swap_cvar, hud_swap_f, 0);
[client] Switch to using canvases for screen and hud Canvases provide layered rendering as for each canvas all components are rendered in turn.
2023-01-20 18:34:33 +00:00
#if 0
[cvar] Make cvars properly typed This is an extremely extensive patch as it hits every cvar, and every usage of the cvars. Cvars no longer store the value they control, instead, they use a cexpr value object to reference the value and specify the value's type (currently, a null type is used for strings). Non-string cvars are passed through cexpr, allowing expressions in the cvars' settings. Also, cvars have returned to an enhanced version of the original (id quake) registration scheme. As a minor benefit, relevant code having direct access to the cvar-controlled variables is probably a slight optimization as it removed a pointer dereference, and the variables can be located for data locality. The static cvar descriptors are made private as an additional safety layer, though there's nothing stopping external modification via Cvar_FindVar (which is needed for adding listeners). While not used yet (partly due to working out the design), cvars can have a validation function. Registering a cvar allows a primary listener (and its data) to be specified: it will always be called first when the cvar is modified. The combination of proper listeners and direct access to the controlled variable greatly simplifies the more complex cvar interactions as much less null checking is required, and there's no need for one cvar's callback to call another's. nq-x11 is known to work at least well enough for the demos. More testing will come.
2022-04-23 03:22:45 +00:00
Cvar_Register (&hud_scoreboard_gravity_cvar, hud_scoreboard_gravity_f, 0);
[client] Switch to using canvases for screen and hud Canvases provide layered rendering as for each canvas all components are rendered in turn.
2023-01-20 18:34:33 +00:00
#endif
}
void
HUD_CreateCanvas (canvas_system_t canvas_sys)
{
hud_canvas = Canvas_New (canvas_sys);
hud_canvas_view = Canvas_GetRootView (canvas_sys, hud_canvas);
View_SetPos (hud_canvas_view, 0, 0);
View_SetLen (hud_canvas_view, viddef.width, viddef.height);
View_SetGravity (hud_canvas_view, grav_northwest);
View_SetVisible (hud_canvas_view, 1);
[cvar] Make cvars properly typed This is an extremely extensive patch as it hits every cvar, and every usage of the cvars. Cvars no longer store the value they control, instead, they use a cexpr value object to reference the value and specify the value's type (currently, a null type is used for strings). Non-string cvars are passed through cexpr, allowing expressions in the cvars' settings. Also, cvars have returned to an enhanced version of the original (id quake) registration scheme. As a minor benefit, relevant code having direct access to the cvar-controlled variables is probably a slight optimization as it removed a pointer dereference, and the variables can be located for data locality. The static cvar descriptors are made private as an additional safety layer, though there's nothing stopping external modification via Cvar_FindVar (which is needed for adding listeners). While not used yet (partly due to working out the design), cvars can have a validation function. Registering a cvar allows a primary listener (and its data) to be specified: it will always be called first when the cvar is modified. The combination of proper listeners and direct access to the controlled variable greatly simplifies the more complex cvar interactions as much less null checking is required, and there's no need for one cvar's callback to call another's. nq-x11 is known to work at least well enough for the demos. More testing will come.
2022-04-23 03:22:45 +00:00
}
void
HUD_Calc_sb_lines (int view_size)
{
[ui] Convert view_t to an ECS entity Much of the nq/qw HUD system is quite broken, but the basic status bar seems to be working nicely. As is the console (both client and server). Possibly the biggest benefit is separating the rendering of HUD elements from the updating of them, and much less traversing of invisible views whose only purpose is to control the positioning of the visible views. The view flow tests are currently disabled until I adapt the flow code to ECS. There seems to be a problem with view resizing in that some gravities don't follow resizing correctly.
2022-10-31 15:40:52 +00:00
#if 0//XXX
[cvar] Make cvars properly typed This is an extremely extensive patch as it hits every cvar, and every usage of the cvars. Cvars no longer store the value they control, instead, they use a cexpr value object to reference the value and specify the value's type (currently, a null type is used for strings). Non-string cvars are passed through cexpr, allowing expressions in the cvars' settings. Also, cvars have returned to an enhanced version of the original (id quake) registration scheme. As a minor benefit, relevant code having direct access to the cvar-controlled variables is probably a slight optimization as it removed a pointer dereference, and the variables can be located for data locality. The static cvar descriptors are made private as an additional safety layer, though there's nothing stopping external modification via Cvar_FindVar (which is needed for adding listeners). While not used yet (partly due to working out the design), cvars can have a validation function. Registering a cvar allows a primary listener (and its data) to be specified: it will always be called first when the cvar is modified. The combination of proper listeners and direct access to the controlled variable greatly simplifies the more complex cvar interactions as much less null checking is required, and there's no need for one cvar's callback to call another's. nq-x11 is known to work at least well enough for the demos. More testing will come.
2022-04-23 03:22:45 +00:00
int stuff_y;
[client] Merge nq and qw cl_view They've been near-identical for years, now they're only one. It proved necessary to start merging the HUD code which for now is just a few cvar declarations (not even init), but that should be a separate set of commits.
2022-02-28 03:12:51 +00:00
[cvar] Make cvars properly typed This is an extremely extensive patch as it hits every cvar, and every usage of the cvars. Cvars no longer store the value they control, instead, they use a cexpr value object to reference the value and specify the value's type (currently, a null type is used for strings). Non-string cvars are passed through cexpr, allowing expressions in the cvars' settings. Also, cvars have returned to an enhanced version of the original (id quake) registration scheme. As a minor benefit, relevant code having direct access to the cvar-controlled variables is probably a slight optimization as it removed a pointer dereference, and the variables can be located for data locality. The static cvar descriptors are made private as an additional safety layer, though there's nothing stopping external modification via Cvar_FindVar (which is needed for adding listeners). While not used yet (partly due to working out the design), cvars can have a validation function. Registering a cvar allows a primary listener (and its data) to be specified: it will always be called first when the cvar is modified. The combination of proper listeners and direct access to the controlled variable greatly simplifies the more complex cvar interactions as much less null checking is required, and there's no need for one cvar's callback to call another's. nq-x11 is known to work at least well enough for the demos. More testing will come.
2022-04-23 03:22:45 +00:00
if (view_size >= 120) {
hud_sb_lines = 0;
stuff_y = 0;
} else if (view_size >= 110) {
hud_sb_lines = 24;
hud_inventory_view->visible = 0;
hud_armament_view->visible = 0;
stuff_y = 32;
} else {
hud_sb_lines = 48;
hud_inventory_view->visible = 1;
hud_armament_view->visible = 1;
stuff_y = 48;
}
if (hud_sb_lines) {
[client] Switch to using canvases for screen and hud Canvases provide layered rendering as for each canvas all components are rendered in turn.
2023-01-20 18:34:33 +00:00
hud_canvas_view->visible = 1;
view_resize (hud_canvas_view, hud_canvas_view->xlen, hud_sb_lines);
[cvar] Make cvars properly typed This is an extremely extensive patch as it hits every cvar, and every usage of the cvars. Cvars no longer store the value they control, instead, they use a cexpr value object to reference the value and specify the value's type (currently, a null type is used for strings). Non-string cvars are passed through cexpr, allowing expressions in the cvars' settings. Also, cvars have returned to an enhanced version of the original (id quake) registration scheme. As a minor benefit, relevant code having direct access to the cvar-controlled variables is probably a slight optimization as it removed a pointer dereference, and the variables can be located for data locality. The static cvar descriptors are made private as an additional safety layer, though there's nothing stopping external modification via Cvar_FindVar (which is needed for adding listeners). While not used yet (partly due to working out the design), cvars can have a validation function. Registering a cvar allows a primary listener (and its data) to be specified: it will always be called first when the cvar is modified. The combination of proper listeners and direct access to the controlled variable greatly simplifies the more complex cvar interactions as much less null checking is required, and there's no need for one cvar's callback to call another's. nq-x11 is known to work at least well enough for the demos. More testing will come.
2022-04-23 03:22:45 +00:00
} else {
[client] Switch to using canvases for screen and hud Canvases provide layered rendering as for each canvas all components are rendered in turn.
2023-01-20 18:34:33 +00:00
hud_canvas_view->visible = 0;
[cvar] Make cvars properly typed This is an extremely extensive patch as it hits every cvar, and every usage of the cvars. Cvars no longer store the value they control, instead, they use a cexpr value object to reference the value and specify the value's type (currently, a null type is used for strings). Non-string cvars are passed through cexpr, allowing expressions in the cvars' settings. Also, cvars have returned to an enhanced version of the original (id quake) registration scheme. As a minor benefit, relevant code having direct access to the cvar-controlled variables is probably a slight optimization as it removed a pointer dereference, and the variables can be located for data locality. The static cvar descriptors are made private as an additional safety layer, though there's nothing stopping external modification via Cvar_FindVar (which is needed for adding listeners). While not used yet (partly due to working out the design), cvars can have a validation function. Registering a cvar allows a primary listener (and its data) to be specified: it will always be called first when the cvar is modified. The combination of proper listeners and direct access to the controlled variable greatly simplifies the more complex cvar interactions as much less null checking is required, and there's no need for one cvar's callback to call another's. nq-x11 is known to work at least well enough for the demos. More testing will come.
2022-04-23 03:22:45 +00:00
}
view_move (hud_stuff_view, hud_stuff_view->xpos, stuff_y);
[ui] Convert view_t to an ECS entity Much of the nq/qw HUD system is quite broken, but the basic status bar seems to be working nicely. As is the console (both client and server). Possibly the biggest benefit is separating the rendering of HUD elements from the updating of them, and much less traversing of invisible views whose only purpose is to control the positioning of the visible views. The view flow tests are currently disabled until I adapt the flow code to ECS. There seems to be a problem with view resizing in that some gravities don't follow resizing correctly.
2022-10-31 15:40:52 +00:00
#endif
}
Reference in a new issue Copy permalink