qf/quakeforge
0
0
Fork 0
mirror of https://git.code.sf.net/p/quake/quakeforge synced 2024-11-22 04:21:51 +00:00
Code Issues Projects Releases Packages Wiki Activity

[ui] Convert view_t to an ECS entity

Browse source 
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.
This commit is contained in:
Bill Currie 2022-11-01 00:40:52 +09:00
parent cf911884c6
commit 817aeb334e
35 changed files with 2263 additions and 1303 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
include/QF/plugin/console.h
View file

@ -52,7 +52,7 @@ typedef struct console_data_s {
void (*quit) (void);
struct cbuf_s *cbuf;
struct view_s *screen_view;
struct view_s *view;
//struct view_s *view;
struct view_s *status_view;
float lines;
int (*exec_line)(void *data, const char *line);

1
include/QF/plugin/vid_render.h
View file

@ -144,7 +144,6 @@ typedef struct vid_render_funcs_s {
typedef struct vid_render_data_s {
viddef_t *vid;
refdef_t *refdef;
struct view_s *scr_view;
int scr_copytop;
int scr_copyeverything;
int scr_fullupdate; // set to 0 to force full redraw

6
include/QF/screen.h
View file

@ -53,8 +53,8 @@ extern int r_zgraph;
extern int scr_copytop;
extern qboolean scr_skipupdate;
struct view_s;
void R_TimeGraph (struct view_s *view);
void R_ZGraph (struct view_s *view);
struct view_pos_s;
void R_TimeGraph (struct view_pos_s abs);
void R_ZGraph (struct view_pos_s abs);
#endif//__QF_screen_h

473
include/QF/ui/view.h
View file

@ -31,6 +31,9 @@
#ifndef __QF_ui_view_h
#define __QF_ui_view_h
#include "QF/ecs/component.h"
#include "QF/ecs/hierarchy.h"
/** \defgroup console_view Console View Objects
\ingroup console
*/
@ -69,275 +72,285 @@ typedef enum {
extern struct exprtype_s grav_t_type;
/** The view object.
*/
typedef struct view_s view_t;
struct view_s {
/// Coordinates of view's origin relative to parent's gravity point.
//@{
int xpos, ypos;
//@}
/// Size of the view.
//@{
int xlen, ylen;
//@}
/** Absolute coordinates of the top left (northwest) corner of the view.
Set interally.
*/
//@{
int xabs, yabs;
//@}
/** Coordinates of the top left (northwest) corner of the view relative to
the parent view's top left corner. Set internally.
*/
//@{
int xrel, yrel;
//@}
typedef struct view_pos_s {
int x;
int y;
} view_pos_t;
typedef struct viewcont_s {
grav_t gravity; ///< The gravity of the view.
unsigned visible:1; ///< If false, view_draw() skips this view.
unsigned resize_x:1; ///< If true, view's width follows parent's.
unsigned resize_y:1; ///< If true, view's height follows parent's.
unsigned bol_suppress:1; ///< If true, view_flow skips at start of line.
unsigned flow_size:1; ///< If true, view's size is adjusted to flow.
view_t *parent; ///< The parent view.
view_t **children; ///< The child views.
int num_children; ///< Number of child views in view.
int max_children; ///< Size of children array.
/** Callback for drawing the view. defaults to view_draw(). if overridden,
the supplied callback should call view_draw() to draw any child views
unless the view is a leaf view.
} viewcont_t;
\note All coordinates are set appropriately before this is called.
\param view This view.
enum {
/// Coordinates of view's origin relative to parent's gravity point.
view_pos,
/// Size of the view.
view_len,
/** Absolute coordinates of the top left (northwest) corner of the view.
Set interally.
*/
void (*draw)(view_t *view);
/** Callback for when the position and/or size of the view changes. Set
this if the underlying drawing system needs to take any action when
the view's geometry changes (eg, moving/resizing the window in curses).
\note All coordinates are set appropriately before this is called.
\param view This view.
view_abs,
/** Coordinates of the top left (northwest) corner of the view relative to
the parent view's top left corner. Set internally.
*/
void (*setgeometry)(view_t *view);
/** User supplied data. Purely for external use. The view functions do not
touch this at all except view_new(), which just sets it to 0.
*/
void *data;
view_rel,
view_oldlen,
view_control,
view_modified,
view_onresize,
view_onmove,
view_type_count
};
/** Create a new view. view_t::draw is set to view_draw() and the view is made
visible. All coordinates are set appropriately for the new view being a
root view. All other fields not set by the parameters are 0.
\param xp The X coordinate of the view's origin.
\param yp The Y coordinate of the view's origin.
\param xl The width of the view.
\param yl The height of the view.
\param grav The gravity of the view. determines the view's origin and
its positioning within the view's parent.
/** The view object.
*/
view_t *view_new (int xp, int yp, int xl, int yl, grav_t grav);
typedef struct view_s {
ecs_registry_t *reg;
uint32_t id;
uint32_t comp;
} view_t;
/** Create a new view. view_t::draw is set to view_draw() and the view is made
visible. All coordinates are set appropriately for the new view being a
root view. All other fields not set by the parameters are 0.
#define nullview ((view_t) {})
\param xp The X coordinate of the view's origin.
\param yp The Y coordinate of the view's origin.
\param xl The width of the view.
\param yl The height of the view.
\param grav The gravity of the view. determines the view's origin and
its positioning within the view's parent.
\param data Pointer with which the view\s data pointer will be
initialized.
*/
view_t *view_new_data (int xp, int yp, int xl, int yl, grav_t grav, void *data);
typedef void (*view_resize_f) (view_t view, view_pos_t len);
typedef void (*view_move_f) (view_t view, view_pos_t abs);
/** Insert a view into a parent view at the specified location. If \c pos is
negative, it is taken to be relative to the end of the parent's list of
views (view_insert (par, view, -1) is equivalent to view_add (par, view)).
\c pos is clipped to be within the correct range.
#define VIEWINLINE GNU89INLINE inline
The absolute X and Y coordianates of the inserted view and its child views
are updated based on the view's gravity.
view_t View_New (ecs_registry_t *reg, view_t parent);
void View_SetParent (view_t view, view_t parent);
void View_UpdateHierarchy (view_t view);
The position of the view within the parent view's child view list
determines the draw order (and thus Z order) of the view, with position 0
being drawn first.
VIEWINLINE hierref_t *View_GetRef (view_t view);
VIEWINLINE int View_Valid (view_t view);
\param par The parent view into which the view is to be inserted.
\param view The view to insert.
\param pos The position at which to insert the view into the parent.
*/
void view_insert (view_t *par, view_t *view, int pos);
VIEWINLINE view_t View_GetParent (view_t view);
VIEWINLINE uint32_t View_ChildCount (view_t view);
VIEWINLINE view_t View_GetChild (view_t view, uint32_t index);
/** Add a view to a parent view at the end of the parents view list.
VIEWINLINE void View_SetPos (view_t view, int x, int y);
VIEWINLINE view_pos_t View_GetPos (view_t view);
VIEWINLINE view_pos_t View_GetAbs (view_t view);
VIEWINLINE view_pos_t View_GetRel (view_t view);
VIEWINLINE void View_SetLen (view_t view, int x, int y);
VIEWINLINE view_pos_t View_GetLen (view_t view);
VIEWINLINE void View_SetGravity (view_t view, grav_t grav);
VIEWINLINE grav_t View_GetGravity (view_t view);
VIEWINLINE void View_SetVisible (view_t view, int visible);
VIEWINLINE int View_GetVisible (view_t view);
VIEWINLINE void View_SetResize (view_t view, int resize_x, int resize_y);
VIEWINLINE void View_SetOnResize (view_t view, view_resize_f onresize);
VIEWINLINE void View_SetOnMove (view_t view, view_move_f onmove);
The absolute X and Y coordianates of the inserted view and its child views
are updated based on the view's gravity.
#undef VIEWINLINE
#ifndef IMPLEMENT_VIEW_Funcs
#define VIEWINLINE GNU89INLINE inline
#else
#define VIEWINLINE VISIBLE
#endif
The added view will be drawn last (and thus on top of earlier views).
VIEWINLINE
hierref_t *
View_GetRef (view_t view)
{
return Ent_GetComponent (view.id, view.comp, view.reg);
}
\param par The parent view to which the view is to be added.
\param view The view to add.
*/
void view_add (view_t *par, view_t *view);
VIEWINLINE
int
View_Valid (view_t view)
{
return view.reg && ECS_EntValid (view.id, view.reg);
}
/** Remove a view from its parent.
VIEWINLINE
view_t
View_GetParent (view_t view)
{
__auto_type ref = View_GetRef (view);
if (ref->index == 0) {
return nullview;
}
hierarchy_t *h = ref->hierarchy;
return (view_t) {
.reg = view.reg,
.id = h->ent[h->parentIndex[ref->index]],
.comp = view.comp,
};
}
\param par The parent view from which the view is to be removed.
\param view The view to remove.
*/
void view_remove (view_t *par, view_t *view);
VIEWINLINE
uint32_t
View_ChildCount (view_t view)
{
__auto_type ref = View_GetRef (view);
hierarchy_t *h = ref->hierarchy;
return h->childCount[ref->index];
}
/** Delete a view and all its child views. If the view has a parent, the view
will be removed from its parent.
VIEWINLINE
view_t
View_GetChild (view_t view, uint32_t childIndex)
{
__auto_type ref = View_GetRef (view);
hierarchy_t *h = ref->hierarchy;
if (childIndex >= h->childCount[ref->index]) {
return nullview;
}
return (view_t) {
.reg = view.reg,
.id = h->ent[h->childIndex[ref->index] + childIndex],
.comp = view.comp,
};
}
\param view The view to delete.
*/
void view_delete (view_t *view);
/** Draw the child views of a view. If a child view is not visible
(view_t::visible is 0), the child will be skipped.
VIEWINLINE
void
View_SetPos (view_t view, int x, int y)
{
__auto_type ref = View_GetRef (view);
hierarchy_t *h = ref->hierarchy;
view_pos_t *pos = h->components[view_pos];
byte *modified = h->components[view_modified];
pos[ref->index] = (view_pos_t) { x, y };
modified[ref->index] |= 1;
}
\note It is best to always use view_t::draw() to draw a view rather than
calling this directly. This function is really for the view's draw
callback to call to draw its sub-views.
VIEWINLINE
view_pos_t
View_GetPos (view_t view)
{
__auto_type ref = View_GetRef (view);
hierarchy_t *h = ref->hierarchy;
view_pos_t *pos = h->components[view_pos];
return pos[ref->index];
}
\param view The view of which to draw the children.
*/
void view_draw (view_t *view);
VIEWINLINE
view_pos_t
View_GetAbs (view_t view)
{
__auto_type ref = View_GetRef (view);
hierarchy_t *h = ref->hierarchy;
view_pos_t *abs = h->components[view_abs];
return abs[ref->index];
}
/** Change the size of a view. The view's children are also resized based on
their view_t::resize_x and view_t::resize_y flags.
VIEWINLINE
view_pos_t
View_GetRel (view_t view)
{
__auto_type ref = View_GetRef (view);
hierarchy_t *h = ref->hierarchy;
view_pos_t *rel = h->components[view_rel];
return rel[ref->index];
}
The absolute X and Y coorinates of the view are updated as necessary to
keep the coordinates of the view's origin correct relative to the view's
geometry.
VIEWINLINE
void
View_SetLen (view_t view, int x, int y)
{
__auto_type ref = View_GetRef (view);
hierarchy_t *h = ref->hierarchy;
view_pos_t *len = h->components[view_len];
view_pos_t *oldlen = h->components[view_oldlen];
byte *modified = h->components[view_modified];
if (!(modified[ref->index] & 2)) {
oldlen[ref->index] = len[ref->index];
}
len[ref->index] = (view_pos_t) { x, y };
modified[ref->index] |= 2;
}
\param view The view to resize.
\param xl The new width of the view.
\param yl The new height of the view.
*/
void view_resize (view_t *view, int xl, int yl);
VIEWINLINE
view_pos_t
View_GetLen (view_t view)
{
__auto_type ref = View_GetRef (view);
hierarchy_t *h = ref->hierarchy;
view_pos_t *len = h->components[view_len];
return len[ref->index];
}
/** Chage the location of a view.
VIEWINLINE
void
View_SetGravity (view_t view, grav_t grav)
{
__auto_type ref = View_GetRef (view);
hierarchy_t *h = ref->hierarchy;
viewcont_t *cont = h->components[view_control];
byte *modified = h->components[view_modified];
cont[ref->index].gravity = grav;
modified[ref->index] |= 1;
}
The absolute X and Y coorinates of the view are updated as necessary to
keep the coordinates of the view's origin correct relative to the view's
geometry.
VIEWINLINE
grav_t
View_GetGravity (view_t view)
{
__auto_type ref = View_GetRef (view);
hierarchy_t *h = ref->hierarchy;
viewcont_t *cont = h->components[view_control];
return cont[ref->index].gravity;
}
\param view The view to move.
\param xp The new X coordinate of the view relative to its gravity.
\param yp The new Y coordinate of the view relative to its gravity.
*/
void view_move (view_t *view, int xp, int yp);
VIEWINLINE
void
View_SetVisible (view_t view, int visible)
{
__auto_type ref = View_GetRef (view);
hierarchy_t *h = ref->hierarchy;
viewcont_t *cont = h->components[view_control];
cont[ref->index].visible = !!visible;
}
/** Chage the location and size of a view in a single operation.
VIEWINLINE
int
View_GetVisible (view_t view)
{
__auto_type ref = View_GetRef (view);
hierarchy_t *h = ref->hierarchy;
viewcont_t *cont = h->components[view_control];
return cont[ref->index].visible;
}
The absolute X and Y coorinates of the view are updated as necessary to
keep the coordinates of the view's origin correct relative to the view's
geometry.
VIEWINLINE
void
View_SetResize (view_t view, int resize_x, int resize_y)
{
__auto_type ref = View_GetRef (view);
hierarchy_t *h = ref->hierarchy;
viewcont_t *cont = h->components[view_control];
cont[ref->index].resize_x = resize_x;
cont[ref->index].resize_y = resize_y;
}
\param view The view to move.
\param xp The new X coordinate of the view relative to its gravity.
\param yp The new Y coordinate of the view relative to its gravity.
\param xl The new width of the view.
\param yl The new height of the view.
*/
void view_setgeometry (view_t *view, int xp, int yp, int xl, int yl);
VIEWINLINE
void
View_SetOnResize (view_t view, view_resize_f onresize)
{
__auto_type ref = View_GetRef (view);
hierarchy_t *h = ref->hierarchy;
view_resize_f *resize = h->components[view_onresize];
resize[ref->index] = onresize;
}
/** Change the gravity of a view, adjusting its position appropriately
\param view The view which will have its gravity set..
\param grav The gravity of the view. determines the view's origin and
its positioning within the view's parent.
*/
void view_setgravity (view_t *view, grav_t grav);
/** Automatic layout of child views by flowing them.
The child views are layed out linearly in the first indicated direction,
and when a child view exceeds the bounds of the view, a new flow line is
started in the second indicated direction. Flow lines always start at the
edge of the view, and the first flow line is at the appropriate edge of
the view such that at least one child view on the line touches the view's
edge and no child view exceeds that edge.
All child views must have gravity set to grav_flow, or their behavior will
be undefined.
A child view with bol_suppress set will not contribute to a flow-line's
length when that child view is the first view on the line, otherwise it
behaves as if bol_suppress is not set.
If the view's flow_size is set, then its secondary axis size is adjusted
so the child views fill the view along that axis. The primary axis size is
never adjusted.
*/
///@{
/** Flow child views from left to right, top to bottom.
Suitable for English and most European scripts.
\param view The parent view containing the children to be flowed.
*/
void view_flow_right_down (view_t *view);
/** Flow child views from right to left, bottom to top.
\param view The parent view containing the children to be flowed.
*/
void view_flow_right_up (view_t *view);
/** Flow child views from right to left, top to bottom.
Suitable for Arabic and similar scripts.
\param view The parent view containing the children to be flowed.
*/
void view_flow_left_down (view_t *view);
/** Flow child views from left to left, bottom to top.
\param view The parent view containing the children to be flowed.
*/
void view_flow_left_up (view_t *view);
/** Flow child views from top to bottom, left to right.
\param view The parent view containing the children to be flowed.
*/
void view_flow_down_right (view_t *view);
/** Flow child views from bottom to top, left to right.
Suitable for English and most European scripts.
\param view The parent view containing the children to be flowed.
*/
void view_flow_up_right (view_t *view);
/** Flow child views from top to bottom, right to left.
Suitable for Asian lanauges (Japanese, Korean, Chinese).
\param view The parent view containing the children to be flowed.
*/
void view_flow_down_left (view_t *view);
/** Flow child views from bottom to top, right to left.
Suitable for English and most European scripts.
\param view The parent view containing the children to be flowed.
*/
void view_flow_up_left (view_t *view);
///@}
VIEWINLINE
void
View_SetOnMove (view_t view, view_move_f onmove)
{
__auto_type ref = View_GetRef (view);
hierarchy_t *h = ref->hierarchy;
view_move_f *move = h->components[view_onmove];
move[ref->index] = onmove;
}
///@}

43
include/client/hud.h
View file

@ -28,25 +28,48 @@
#ifndef __client_hud_h
#define __client_hud_h
enum {
hud_href,
hud_tile,
hud_pic,
hud_subpic,
hud_cachepic,
hud_fill,
hud_charbuff,
hud_func,
hud_comp_count
};
typedef struct hud_subpic_s {
struct qpic_s *pic;
uint32_t x, y;
uint32_t w, h;
} hud_subpic_t;
extern struct ecs_registry_s *hud_registry;
extern int hud_sb_lines;
extern int hud_sbar;
extern int hud_swap;
extern struct view_s *sbar_view;
extern struct view_s *sbar_inventory_view;
extern struct view_s *sbar_frags_view;
//extern struct view_s sbar_view;
//extern struct view_s sbar_inventory_view;
//extern struct view_s sbar_frags_view;
extern struct view_s *hud_view;
extern struct view_s *hud_inventory_view;
extern struct view_s *hud_armament_view;
extern struct view_s *hud_frags_view;
extern struct view_s hud_view;
extern struct view_s hud_inventory_view;
extern struct view_s hud_armament_view;
extern struct view_s hud_frags_view;
extern struct view_s *hud_overlay_view;
extern struct view_s *hud_stuff_view;
extern struct view_s *hud_main_view;
extern struct view_s hud_overlay_view;
extern struct view_s hud_stuff_view;
extern struct view_s hud_main_view;
void HUD_Init (void);
void HUD_Init_Cvars (void);
void HUD_Calc_sb_lines (int view_size);
void HUD_Draw_Views (void);
#endif//__client_hud_h

3
include/r_font.h
View file

@ -39,6 +39,9 @@
#include "r_scrap.h"
typedef struct fontent_s {
uint32_t id;
} fontent_t;
typedef struct rfont_s {
void *font_resource;

12
include/r_text.h
View file

@ -36,6 +36,14 @@
#include "QF/darray.h"
#include "QF/ecs/component.h"
typedef struct script_component_s {
hb_language_t language;
hb_script_t script;
hb_direction_t direction;
} script_component_t;
typedef struct rtext_s {
const char *text;
const char *language;
@ -56,8 +64,8 @@ typedef struct rshaper_s {
r_hb_featureset_t features;
} rshaper_t;
extern hb_feature_t LiagureOff;
extern hb_feature_t LiagureOn;
extern hb_feature_t LigatureOff;
extern hb_feature_t LigatureOn;
extern hb_feature_t KerningOff;
extern hb_feature_t KerningOn;
extern hb_feature_t CligOff;

12
include/sbar.h
View file

@ -40,7 +40,17 @@ void Sbar_Init (void);
struct cvar_s;
void Sbar_DMO_Init_f (void *data, const struct cvar_s *var);
void Sbar_Changed (void);
typedef enum {
sbc_ammo,
sbc_armor,
sbc_frags,
sbc_health,
sbc_info,
sbc_items,
sbc_weapon,
} sbar_changed;
void Sbar_Changed (sbar_changed change);
// call whenever any of the client stats represented on the sbar changes
void Sbar_Draw (void);

12
include/sv_console.h
View file

@ -1,13 +1,21 @@
#ifndef __sv_console_h
#define __sv_console_h
enum {
server_href,
server_view,
server_window,
server_comp_count
};
struct view_s;
typedef struct sv_view_s {
void *win;
void *obj;
void (*draw) (struct view_s *view);
void (*setgeometry) (struct view_s *view);
void (*draw) (struct view_s view);
void (*setgeometry) (struct view_s view);
} sv_view_t;
typedef struct sv_sbar_s {

208
libs/client/hud.c
View file

@ -41,6 +41,42 @@
#include "client/hud.h"
static const component_t hud_components[hud_comp_count] = {
[hud_href] = {
.size = sizeof (hierref_t),
.name = "href",
},
[hud_tile] = {
.size = sizeof (byte),
.name = "pic",
},
[hud_pic] = {
.size = sizeof (qpic_t *),
.name = "pic",
},
[hud_subpic] = {
.size = sizeof (hud_subpic_t),
.name = "subpic",
},
[hud_cachepic] = {
.size = sizeof (const char *),
.name = "cachepic",
},
[hud_fill] = {
.size = sizeof (uint32_t),
.name = "fill",
},
[hud_charbuff] = {
.size = sizeof (draw_charbuffer_t *),
.name = "charbuffer",
},
[hud_func] = {
.size = sizeof (void (*)(view_pos_t)),
.name = "func",
},
};
ecs_registry_t *hud_registry;
int hud_sb_lines;
int hud_sbar;
@ -72,24 +108,25 @@ static cvar_t hud_swap_cvar = {
.value = { .type = &cexpr_int, .value = &hud_swap },
};
view_t *sbar_view;
view_t *sbar_inventory_view;
view_t *sbar_frags_view;
view_t sbar_view;
view_t sbar_inventory_view;
view_t sbar_frags_view;
view_t *hud_view;
view_t *hud_inventory_view;
view_t *hud_armament_view;
view_t *hud_frags_view;
view_t hud_view;
view_t hud_inventory_view;
view_t hud_armament_view;
view_t hud_frags_view;
view_t *hud_overlay_view;
view_t *hud_stuff_view;
view_t *hud_main_view;
view_t hud_overlay_view;
view_t hud_stuff_view;
view_t hud_main_view;
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);
#if 0//XXX
if (hud_sbar) {
view_remove (hud_main_view, hud_main_view->children[0]);
view_insert (hud_main_view, sbar_view, 0);
@ -97,11 +134,13 @@ hud_sbar_f (void *data, const cvar_t *cvar)
view_remove (hud_main_view, hud_main_view->children[0]);
view_insert (hud_main_view, hud_view, 0);
}
#endif
}
static void
hud_swap_f (void *data, const cvar_t *cvar)
{
#if 0//XXX
if (hud_swap) {
//FIXME why is this needed for nq but not for qw?
hud_armament_view->children[0]->gravity = grav_northwest;
@ -118,12 +157,25 @@ hud_swap_f (void *data, const cvar_t *cvar)
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);
#endif
}
static void
hud_scoreboard_gravity_f (void *data, const cvar_t *cvar)
{
#if 0//XXX
view_setgravity (hud_overlay_view, hud_scoreboard_gravity);
#endif
}
void
HUD_Init (void)
{
hud_registry = ECS_NewRegistry ();
ECS_RegisterComponents (hud_registry, hud_components, hud_comp_count);
hud_registry->href_comp = hud_href;
hud_view = View_New (hud_registry, nullview);
}
void
@ -137,6 +189,7 @@ HUD_Init_Cvars (void)
void
HUD_Calc_sb_lines (int view_size)
{
#if 0//XXX
int stuff_y;
if (view_size >= 120) {
@ -165,4 +218,139 @@ HUD_Calc_sb_lines (int view_size)
hud_view->visible = 0;
}
view_move (hud_stuff_view, hud_stuff_view->xpos, stuff_y);
#endif
}
static void
draw_tile_views (ecs_pool_t *pool)
{
uint32_t count = pool->count;
uint32_t *ent = pool->dense;
while (count-- > 0) {
view_t view = { .id = *ent++, .reg = hud_registry };
if (View_GetVisible (view)) {
view_pos_t pos = View_GetAbs (view);
view_pos_t len = View_GetLen (view);
r_funcs->Draw_TileClear (pos.x, pos.y, len.x, len.y);
}
}
}
static void
draw_pic_views (ecs_pool_t *pool)
{
uint32_t count = pool->count;
uint32_t *ent = pool->dense;
qpic_t **pic = pool->data;
while (count-- > 0) {
view_t view = { .id = *ent++, .reg = hud_registry };
if (View_GetVisible (view)) {
view_pos_t pos = View_GetAbs (view);
r_funcs->Draw_Pic (pos.x, pos.y, *pic);
}
pic++;
}
}
static void
draw_subpic_views (ecs_pool_t *pool)
{
uint32_t count = pool->count;
uint32_t *ent = pool->dense;
hud_subpic_t *subpic = pool->data;
while (count-- > 0) {
view_t view = { .id = *ent++, .reg = hud_registry };
if (View_GetVisible (view)) {
view_pos_t pos = View_GetAbs (view);
r_funcs->Draw_SubPic (pos.x, pos.y, subpic->pic,
subpic->x, subpic->y, subpic->w, subpic->h);
}
subpic++;
}
}
static void
draw_cachepic_views (ecs_pool_t *pool)
{
uint32_t count = pool->count;
uint32_t *ent = pool->dense;
const char **name = pool->data;
while (count-- > 0) {
view_t view = { .id = *ent++, .reg = hud_registry };
if (View_GetVisible (view)) {
view_pos_t pos = View_GetAbs (view);
qpic_t *pic = r_funcs->Draw_CachePic (*name, 1);
r_funcs->Draw_Pic (pos.x, pos.y, pic);
}
name++;
}
}
static void
draw_fill_views (ecs_pool_t *pool)
{
uint32_t count = pool->count;
uint32_t *ent = pool->dense;
uint32_t *fill = pool->data;
while (count-- > 0) {
view_t view = { .id = *ent++, .reg = hud_registry };
if (View_GetVisible (view)) {
view_pos_t pos = View_GetAbs (view);
view_pos_t len = View_GetLen (view);
r_funcs->Draw_Fill (pos.x, pos.y, len.x, len.y, *fill);
}
fill++;
}
}
static void
draw_charbuff_views (ecs_pool_t *pool)
{
uint32_t count = pool->count;
uint32_t *ent = pool->dense;
draw_charbuffer_t **charbuff = pool->data;
while (count-- > 0) {
view_t view = { .id = *ent++, .reg = hud_registry };
if (View_GetVisible (view)) {
view_pos_t pos = View_GetAbs (view);
r_funcs->Draw_CharBuffer (pos.x, pos.y, *charbuff);
}
charbuff++;
}
}
static void
draw_func_views (ecs_pool_t *pool)
{
uint32_t count = pool->count;
uint32_t *ent = pool->dense;
void (**func) (view_pos_t, view_pos_t) = pool->data;
while (count-- > 0) {
view_t view = { .id = *ent++, .reg = hud_registry };
if (View_GetVisible (view)) {
view_pos_t pos = View_GetAbs (view);
view_pos_t len = View_GetLen (view);
(*func) (pos, len);
}
func++;
}
}
void
HUD_Draw_Views (void)
{
static void (*draw_func[hud_comp_count]) (ecs_pool_t *) = {
[hud_tile] = draw_tile_views,
[hud_pic] = draw_pic_views,
[hud_subpic] = draw_subpic_views,
[hud_cachepic] = draw_cachepic_views,
[hud_fill] = draw_fill_views,
[hud_charbuff] = draw_charbuff_views,
[hud_func] = draw_func_views,
};
for (int i = 0; i < hud_comp_count; i++) {
if (draw_func[i]) {
draw_func[i] (&hud_registry->comp_pools[i]);
}
}
}

463
libs/console/client.c
View file

@ -143,6 +143,8 @@ static cvar_t cl_conmode_cvar = {
.value = { .type = &cl_conmode_type, .value = &con_data.exec_line },
};
static ecs_registry_t *client_reg;
static con_state_t con_state;
static int con_event_id;
static int con_saved_focos;
@ -153,36 +155,92 @@ static qboolean chat_team;
typedef struct {
const char *prompt;
inputline_t *input_line;
view_t *view;
draw_charbuffer_t *buffer;
} con_input_t;
enum {
client_href,
client_input,
client_charbuff,
client_cursor,
client_comp_count
};
static const component_t client_components[client_comp_count] = {
[client_href] = {
.size = sizeof (hierref_t),
.name = "href",
},
[client_input] = {
.size = sizeof (con_input_t *),
.name = "input",
},
[client_charbuff] = {
.size = sizeof (draw_charbuffer_t *),
.name = "charbuff",
},
[client_cursor] = {
.size = sizeof (con_input_t *),
.name = "cursor",
},
};
#define MAXCMDLINE 256
static con_input_t cmd_line;
static con_input_t say_line;
static con_input_t team_line;
static inputline_t *chat_input;
static inputline_t *team_input;
static view_t screen_view;
static view_t console_view;
static view_t buffer_view;
static view_t command_view;
static view_t download_view;
static view_t notify_view;
static view_t say_view;
#define CON_BUFFER_SIZE 32768
#define CON_LINES 1024
static view_t *console_view;
static draw_charbuffer_t *console_buffer;
static con_buffer_t *con_main;
static int view_offset;
static draw_charbuffer_t *download_buffer;
#define NOTIFY_LINES 4
static view_t *notify_view;
static draw_charbuffer_t *notify_buffer;
// ring buffer holding realtime time the line was generated
static float notify_times[NOTIFY_LINES + 1];
static int notify_head;
static int notify_tail;
static view_t *menu_view;
static view_t *hud_view;
static qboolean con_initialized;
static inline void *
con_getcomponent (view_t view, uint32_t comp)
{
return Ent_GetComponent (view.id, comp, view.reg);
}
static inline int
con_hascomponent (view_t view, uint32_t comp)
{
return Ent_HasComponent (view.id, comp, view.reg);
}
static inline void *
con_setcomponent (view_t view, uint32_t comp, void *data)
{
return Ent_SetComponent (view.id, comp, view.reg, data);
}
static inline void
con_remcomponent (view_t view, uint32_t comp)
{
Ent_RemoveComponent (view.id, comp, view.reg);
}
static void
ClearNotify (void)
{
@ -204,11 +262,15 @@ C_SetState (con_state_t state)
if (state == con_message) {
say_line.prompt = "say:";
say_line.input_line = chat_input;
if (chat_team) {
say_line.prompt = "say_team:";
say_line.input_line = team_input;
}
say_line.buffer->cursx = 0;
Draw_PrintBuffer (say_line.buffer, say_line.prompt);
__auto_type buffer = say_line.buffer;
buffer->cursx = 0;
Draw_PrintBuffer (buffer, say_line.prompt);
say_line.input_line->width = buffer->width - buffer->cursx;
}
if (con_state == con_menu && old_state != con_menu) {
@ -374,19 +436,7 @@ C_Print (const char *fmt, va_list args)
/* DRAWING */
static void
draw_cursor (int x, int y, inputline_t *il)
{
if (!con_data.realtime) {
return;
}
float t = *con_data.realtime * con_cursorspeed;
int ch = 10 + ((int) (t) & 1);
r_funcs->Draw_Character (x + ((il->linepos - il->scroll) * 8), y, ch);
}
static void
DrawInputLine (int x, int y, int cursor, inputline_t *il)
DrawInputLine (int x, int y, inputline_t *il)
{
const char *s = il->lines[il->edit_line] + il->scroll;
@ -396,9 +446,6 @@ DrawInputLine (int x, int y, int cursor, inputline_t *il)
} else {
r_funcs->Draw_nString (x, y, s, il->width - 1);
}
if (cursor) {
draw_cursor (x, y, il);
}
if (strlen (s) >= il->width)
r_funcs->Draw_Character (x + ((il->width - 1) * 8), y, '>' | 0x80);
}
@ -406,7 +453,7 @@ DrawInputLine (int x, int y, int cursor, inputline_t *il)
void
C_DrawInputLine (inputline_t *il)
{
DrawInputLine (il->x, il->y, il->cursor, il);
DrawInputLine (il->x, il->y, il);
}
static void
@ -426,16 +473,6 @@ draw_input_line (inputline_t *il, draw_charbuffer_t *buffer)
*dst++ = *src ? '>' | 0x80 : ' ';
}
static void
draw_input (view_t *view)
{
__auto_type inp = (con_input_t *) view->data;
Draw_CharBuffer (view->xabs, view->yabs, inp->buffer);
draw_cursor (view->xabs + inp->buffer->cursx * 8, view->yabs,
inp->input_line);
}
static void
input_line_draw (inputline_t *il)
{
@ -444,29 +481,34 @@ input_line_draw (inputline_t *il)
}
static void
resize_input (view_t *view)
resize_input (view_t view, view_pos_t len)
{
__auto_type inp = (con_input_t *) view->data;
if (!con_hascomponent (view, client_input)) {
return;
}
__auto_type inp = *(con_input_t **) con_getcomponent (view, client_input);
if (inp->buffer) {
Draw_DestroyBuffer (inp->buffer);
}
inp->buffer = Draw_CreateBuffer (view->xlen / 8, 1);
inp->buffer = Draw_CreateBuffer (len.x / 8, 1);
Draw_ClearBuffer (inp->buffer);
Draw_PrintBuffer (inp->buffer, inp->prompt);
inp->buffer->chars[inp->buffer->cursx] = inp->input_line->prompt_char;
inp->input_line->width = inp->buffer->width - inp->buffer->cursx;
if (inp->input_line) {
inp->input_line->width = inp->buffer->width - inp->buffer->cursx;
printf ("resize_input: %d %zd %d %d %d\n", view.id,
inp->input_line->width,
len.x, inp->buffer->width, inp->buffer->cursx);
inp->buffer->chars[inp->buffer->cursx] = inp->input_line->prompt_char;
}
}
static void
draw_download (view_t *view)
update_download (void)
{
static dstring_t *dlbar;
const char *text;
if (!con_data.dl_name || !*con_data.dl_name->str)
return;
if (!dlbar) {
dlbar = dstring_new ();
}
@ -500,15 +542,14 @@ draw_download (view_t *view)
dsprintf (dlbar, "%.*s%s: \x80%s\x82 %02d%%",
txt_size, text, ellipsis, dots, *con_data.dl_percent);
// draw it
r_funcs->Draw_String (view->xabs, view->yabs, dlbar->str);
}
static void
draw_console_text (view_t *view)
{
Draw_CharBuffer (view->xabs, view->yabs, console_buffer);
int i;
for (i = 0; i < download_buffer->width && dlbar->str[i]; i++) {
download_buffer->chars[i] = dlbar->str[i];
}
for (; i < download_buffer->width; i++) {
download_buffer->chars[i] = ' ';
}
}
static void
@ -519,15 +560,16 @@ clear_console_text (void)
}
static void
resize_console_text (view_t *view)
resize_console_text (view_t view, view_pos_t len)
{
int width = view->xlen / 8;
int height = view->ylen / 8;
int width = len.x / 8;
int height = len.y / 8;
if (console_buffer->width != width || console_buffer->height != height) {
con_linewidth = width;
Draw_DestroyBuffer (console_buffer);
console_buffer = Draw_CreateBuffer (width, height);
con_setcomponent (buffer_view, client_charbuff, &console_buffer);
clear_console_text ();
}
}
@ -556,26 +598,49 @@ draw_con_scrollback (void)
}
static void
draw_console (view_t *view)
draw_cursor (void)
{
byte alpha;
if (con_state == con_fullscreen) {
alpha = 255;
} else {
float y = con_data.screen_view->ylen * con_size;
alpha = 255 * con_alpha * view->ylen / y;
alpha = min (alpha, 255);
if (!con_data.realtime) {
return;
}
// draw the background
r_funcs->Draw_ConsoleBackground (con_data.lines, alpha);
// draw everything else
view_draw (view);
float t = *con_data.realtime * con_cursorspeed;
int ch = 10 + ((int) (t) & 1);
ecs_pool_t *pool = &client_reg->comp_pools[client_cursor];
con_input_t **inp = pool->data;
uint32_t *id = pool->dense;
for (uint32_t i = pool->count; i-- > 0; ) {
__auto_type buff = (*inp)->buffer;
__auto_type il = (*inp++)->input_line;
view_t v = { .reg = client_reg, .id = *id++,
.comp = screen_view.comp };
if (!il->cursor) {
continue;
}
view_pos_t pos = View_GetAbs (v);
int x = (buff->cursx + il->linepos - il->scroll) * 8;
r_funcs->Draw_Character (pos.x + x, pos.y, ch);
}
}
static void
draw_notify (view_t *view)
draw_buffer (void)
{
ecs_pool_t *pool = &client_reg->comp_pools[client_charbuff];
draw_charbuffer_t **buffer = pool->data;
uint32_t *id = pool->dense;
for (uint32_t i = pool->count; i-- > 0; ) {
view_t v = { .reg = client_reg, .id = *id++,
.comp = screen_view.comp };
view_pos_t pos = View_GetAbs (v);
Draw_CharBuffer (pos.x, pos.y, *buffer++);
}
}
static void
update_notify (void)
{
if (con_data.realtime && notify_tail != notify_head
&& *con_data.realtime - notify_times[notify_tail] > con_notifytime) {
@ -586,21 +651,53 @@ draw_notify (view_t *view)
notify_tail -= NOTIFY_LINES + 1;
}
}
Draw_CharBuffer (view->xabs, view->yabs, notify_buffer);
}
static void
resize_notify (view_t *view)
draw_console (view_t view)
{
byte alpha;
if (con_state == con_fullscreen) {
alpha = 255;
} else {
view_pos_t len = View_GetLen (screen_view);
float y = len.y * con_size;
alpha = 255 * con_alpha * len.y / y;
alpha = min (alpha, 255);
}
// draw the background
r_funcs->Draw_ConsoleBackground (con_data.lines, alpha);
update_notify ();
// draw everything else
draw_buffer ();
draw_cursor ();
}
static void
resize_notify (view_t view, view_pos_t len)
{
Draw_DestroyBuffer (notify_buffer);
notify_buffer = Draw_CreateBuffer (view->xlen / 8, NOTIFY_LINES + 1);
notify_buffer = Draw_CreateBuffer (len.x / 8, NOTIFY_LINES + 1);
con_setcomponent (notify_view, client_charbuff, &notify_buffer);
ClearNotify ();
}
static void
resize_download (view_t view, view_pos_t len)
{
if (download_buffer) {
Draw_DestroyBuffer (download_buffer);
download_buffer = Draw_CreateBuffer (len.x / 8, 1);
}
}
static void
setup_console (void)
{
float lines = 0;
view_pos_t screen_len = View_GetLen (screen_view);
switch (con_state) {
case con_message:
@ -609,11 +706,10 @@ setup_console (void)
lines = 0;
break;
case con_active:
lines = con_data.screen_view->ylen * bound (0.2, con_size,
1);
lines = screen_len.y * bound (0.2, con_size, 1);
break;
case con_fullscreen:
lines = con_data.lines = con_data.screen_view->ylen;
lines = con_data.lines = screen_len.y;
break;
}
@ -628,10 +724,10 @@ setup_console (void)
} else {
con_data.lines = lines;
}
if (con_data.lines > con_data.screen_view->ylen) {
con_data.lines = con_data.screen_view->ylen;
if (con_data.lines > screen_len.y) {
con_data.lines = screen_len.y;
}
if (con_data.lines >= con_data.screen_view->ylen - r_data->lineadj)
if (con_data.lines >= screen_len.y - r_data->lineadj)
r_data->scr_copyeverything = 1;
}
@ -639,18 +735,44 @@ static void
C_DrawConsole (void)
{
setup_console ();
view_pos_t screen_len = View_GetLen (screen_view);
int ypos = con_data.lines - con_data.screen_view->ylen;
if (console_view->ypos != ypos) {
view_move (console_view, 0, ypos);
view_pos_t pos = View_GetPos (console_view);
int ypos = con_data.lines - screen_len.y;
if (pos.y != ypos) {
View_SetPos (console_view, pos.x, ypos);
View_UpdateHierarchy (console_view);
}
say_line.view->visible = con_state == con_message ? !chat_team : 0;
team_line.view->visible = con_state == con_message ? chat_team : 0;
console_view->visible = con_data.lines != 0;
menu_view->visible = con_state == con_menu;
if (con_state == con_message) {
con_setcomponent (say_view, client_charbuff, &say_line.buffer);
con_input_t *inp = &say_line;
con_setcomponent (say_view, client_cursor, &inp);
} else {
con_remcomponent (say_view, client_charbuff);
con_remcomponent (say_view, client_cursor);
}
if (con_data.lines) {
con_setcomponent (command_view, client_charbuff, &cmd_line.buffer);
con_input_t *inp = &cmd_line;
con_setcomponent (command_view, client_cursor, &inp);
} else {
con_remcomponent (command_view, client_charbuff);
con_remcomponent (command_view, client_cursor);
}
if (con_data.dl_name && *con_data.dl_name->str) {
if (!download_buffer) {
view_pos_t len = View_GetLen (download_view);
download_buffer = Draw_CreateBuffer (len.x / 8, 1);
con_setcomponent (download_view, client_charbuff, &download_buffer);
}
update_download ();
} else if (download_buffer) {
Draw_DestroyBuffer (download_buffer);
con_remcomponent (download_view, client_charbuff);
}
con_data.view->draw (con_data.view);
draw_console (screen_view);
}
static void
@ -668,13 +790,13 @@ C_NewMap (void)
static void
C_GIB_HUD_Enable_f (void)
{
hud_view->visible = 1;
//hud_view->visible = 1;
}
static void
C_GIB_HUD_Disable_f (void)
{
hud_view->visible = 0;
//hud_view->visible = 0;
}
static void
@ -690,14 +812,15 @@ exec_line (inputline_t *il)
static void
con_app_window (const IE_event_t *event)
{
static int old_xlen;
static int old_ylen;
static int old_xlen = -1;
static int old_ylen = -1;
if (old_xlen != event->app_window.xlen
|| old_ylen != event->app_window.ylen) {
old_xlen = event->app_window.xlen;
old_ylen = event->app_window.ylen;
view_resize (con_data.view, old_xlen, old_ylen);
View_SetLen (screen_view, old_xlen, old_ylen);
View_UpdateHierarchy (screen_view);
}
}
@ -723,9 +846,9 @@ con_key_event (const IE_event_t *event)
#endif
if (con_state == con_message) {
if (chat_team) {
il = team_line.input_line;
il = team_input;
} else {
il = say_line.input_line;
il = chat_input;
}
if (key->code == QFK_ESCAPE) {
con_end_message (il);
@ -862,7 +985,9 @@ Condump_f (void)
static void
C_Init (void)
{
view_t *view;
client_reg = ECS_NewRegistry ();
ECS_RegisterComponents (client_reg, client_components, client_comp_count);
client_reg->href_comp = client_href;
#ifdef __QNXNTO__
setlocale (LC_ALL, "C-TRADITIONAL");
@ -882,11 +1007,45 @@ C_Init (void)
con_debuglog = COM_CheckParm ("-condebug");
// The console will get resized, so assume initial size is 320x200
con_data.view = view_new (0, 0, 320, 200, grav_northeast);
console_view = view_new (0, 0, 320, 200, grav_northwest);
notify_view = view_new (8, 8, 312, NOTIFY_LINES * 8, grav_northwest);
menu_view = view_new (0, 0, 320, 200, grav_center);
hud_view = view_new (0, 0, 320, 200, grav_northeast);
screen_view = View_New (client_reg, nullview);
console_view = View_New (client_reg, screen_view);
buffer_view = View_New (client_reg, console_view);
command_view = View_New (client_reg, console_view);
download_view = View_New (client_reg, console_view);
notify_view = View_New (client_reg, screen_view);
say_view = View_New (client_reg, screen_view);
View_SetGravity (screen_view, grav_northwest);
View_SetGravity (console_view, grav_northwest);
View_SetGravity (buffer_view, grav_southwest);
View_SetGravity (command_view, grav_southwest);
View_SetGravity (download_view, grav_southwest);
View_SetGravity (notify_view, grav_northwest);
View_SetGravity (say_view, grav_northwest);
View_SetResize (screen_view, 1, 1);
View_SetResize (console_view, 1, 1);
View_SetResize (buffer_view, 1, 1);
View_SetResize (command_view, 1, 0);
View_SetResize (download_view, 1, 0);
View_SetResize (notify_view, 1, 0);
View_SetResize (say_view, 1, 0);
View_SetPos (screen_view, 0, 0);
View_SetPos (console_view, 0, 0);
View_SetPos (buffer_view, 0, 24);
View_SetPos (command_view, 0, 0);
View_SetPos (download_view, 0, 2);
View_SetPos (notify_view, 8, 8);
View_SetPos (say_view, 0, 0);
View_SetLen (screen_view, 320, 200);
View_SetLen (console_view, 320, 200);
View_SetLen (buffer_view, 320, 176);
View_SetLen (command_view, 320, 12);
View_SetLen (download_view, 320, 8);
View_SetLen (notify_view, 312, NOTIFY_LINES * 8);
View_SetLen (say_view, 320, 8);
cmd_line.prompt = "";
cmd_line.input_line = Con_CreateInputLine (32, MAXCMDLINE, ']');
@ -895,83 +1054,67 @@ C_Init (void)
cmd_line.input_line->width = con_linewidth;
cmd_line.input_line->user_data = &cmd_line;
cmd_line.input_line->draw = input_line_draw;
cmd_line.view = view_new_data (0, 12, 320, 10, grav_southwest, &cmd_line);
cmd_line.view->draw = draw_input;
cmd_line.view->setgeometry = resize_input;
cmd_line.view->resize_x = 1;
view_add (console_view, cmd_line.view);
say_line.prompt = "say:";
say_line.input_line = Con_CreateInputLine (32, MAXCMDLINE, ' ');
say_line.input_line->complete = 0;
say_line.input_line->enter = C_Say;
say_line.input_line->width = con_linewidth - 5;
say_line.input_line->user_data = &say_line;
say_line.input_line->draw = input_line_draw;
say_line.view = view_new_data (0, 0, 320, 8, grav_northwest, &say_line);
say_line.view->draw = draw_input;
say_line.view->setgeometry = resize_input;
say_line.view->visible = 0;
say_line.view->resize_x = 1;
view_add (con_data.view, say_line.view);
chat_input = Con_CreateInputLine (32, MAXCMDLINE, ' ');
chat_input->complete = 0;
chat_input->enter = C_Say;
chat_input->width = con_linewidth - 5;
chat_input->user_data = &say_line;
chat_input->draw = input_line_draw;
team_line.prompt = "say_team:";
team_line.input_line = Con_CreateInputLine (32, MAXCMDLINE, ' ');
team_line.input_line->complete = 0;
team_line.input_line->enter = C_SayTeam;
team_line.input_line->width = con_linewidth - 10;
team_line.input_line->user_data = &team_line;
team_line.input_line->draw = input_line_draw;
team_line.view = view_new_data (0, 0, 320, 8, grav_northwest, &team_line);
team_line.view->draw = draw_input;
team_line.view->setgeometry = resize_input;
team_line.view->visible = 0;
team_line.view->resize_x = 1;
view_add (con_data.view, team_line.view);
team_input = Con_CreateInputLine (32, MAXCMDLINE, ' ');
team_input->complete = 0;
team_input->enter = C_SayTeam;
team_input->width = con_linewidth - 10;
team_input->user_data = &say_line;
team_input->draw = input_line_draw;
view_add (con_data.view, notify_view);
view_add (con_data.view, hud_view);
view_add (con_data.view, console_view);
view_add (con_data.view, menu_view);
{
con_input_t *inp = &say_line;
con_setcomponent (say_view, client_input, &inp);
}
{
con_input_t *inp = &cmd_line;
con_setcomponent (command_view, client_input, &inp);
}
console_buffer = Draw_CreateBuffer (console_view->xlen / 8,
console_view->ylen / 8);
view_pos_t len;
len = View_GetLen (buffer_view);
console_buffer = Draw_CreateBuffer (len.x / 8, len.y / 8);
Draw_ClearBuffer (console_buffer);
con_setcomponent (buffer_view, client_charbuff, &console_buffer);
con_main = Con_CreateBuffer (CON_BUFFER_SIZE, CON_LINES);
console_view->draw = draw_console;
console_view->visible = 0;
console_view->resize_x = console_view->resize_y = 1;
len = View_GetLen (command_view);
cmd_line.buffer = Draw_CreateBuffer (len.x / 8, len.y / 8);
Draw_ClearBuffer (cmd_line.buffer);
con_setcomponent (command_view, client_charbuff, &cmd_line.buffer);
notify_buffer = Draw_CreateBuffer (notify_view->xlen / 8, NOTIFY_LINES + 1);
len = View_GetLen (notify_view);
notify_buffer = Draw_CreateBuffer (len.x / 8, NOTIFY_LINES + 1);
Draw_ClearBuffer (notify_buffer);
notify_view->draw = draw_notify;
notify_view->setgeometry = resize_notify;
notify_view->resize_x = 1;
con_setcomponent (notify_view, client_charbuff, &notify_buffer);
menu_view->draw = Menu_Draw;
menu_view->visible = 0;
len = View_GetLen (say_view);
say_line.buffer = Draw_CreateBuffer (len.x / 8, len.y / 8);
Draw_ClearBuffer (say_line.buffer);
hud_view->draw = Menu_Draw_Hud;
hud_view->visible = 0;
View_UpdateHierarchy (screen_view);
view = view_new (8, 16, 320, 168, grav_southwest);
view->draw = draw_console_text;
view->setgeometry = resize_console_text;
view->resize_x = view->resize_y = 1;
view_add (console_view, view);
view = view_new (0, 2, 320, 11, grav_southwest);
view->draw = draw_download;
view->resize_x = 1;
view_add (console_view, view);
// set onresize after View_UpdateHierarchy so the callbacks are NOT called
// during init
View_SetOnResize (buffer_view, resize_console_text);
View_SetOnResize (command_view, resize_input);
View_SetOnResize (download_view, resize_download);
View_SetOnResize (notify_view, resize_notify);
View_SetOnResize (say_view, resize_input);
con = con_main;
con_linewidth = -1;
Sys_Printf ("Console initialized.\n");
// register our commands

4
libs/console/menu.c
View file

@ -679,8 +679,8 @@ Menu_Draw (view_t *view)
if (!menu)
return;
x = view->xabs;
y = view->yabs;
x = 0;//view->xabs;
y = 0;//view->yabs;
if (menu->fadescreen)
r_funcs->Draw_FadeScreen ();

243
libs/console/server.c
View file

@ -148,13 +148,16 @@ enum {
static int use_curses = 1;
static view_t *output;
static view_t *status;
static view_t *input;
static view_t sv_view;
static view_t output;
static view_t status;
static view_t input;
static int screen_x, screen_y;
static volatile sig_atomic_t interrupted;
static int batch_print;
static ecs_registry_t *server_reg;
#define MAXCMDLINE 256
#define BUFFER_SIZE 32768
@ -211,6 +214,21 @@ static const byte attr_map[256] = {
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
};
static const component_t server_components[server_comp_count] = {
[server_href] = {
.size = sizeof (hierref_t),
.name = "href",
},
[server_view] = {
.size = sizeof (sv_view_t),
.name = "sv_view",
},
[server_window] = {
.size = sizeof (sv_view_t),
.name = "sv_window",
},
};
static inline void
draw_fun_char (WINDOW *win, byte c, int blue)
@ -222,37 +240,45 @@ draw_fun_char (WINDOW *win, byte c, int blue)
}
static inline void
sv_refresh (view_t *view)
sv_refresh_windows (void)
{
sv_view_t *sv_view = view->data;
wnoutrefresh ((WINDOW *) sv_view->win);
sv_view_t *window = server_reg->comp_pools[server_window].data;
uint32_t count = server_reg->comp_pools[server_window].count;
while (count-- > 0) {
wnoutrefresh ((WINDOW *) (window++)->win);
}
doupdate ();
}
static inline int
sv_getch (view_t *view)
sv_getch (view_t view)
{
sv_view_t *sv_view = view->data;
return wgetch ((WINDOW *) sv_view->win);
sv_view_t *window = Ent_GetComponent (view.id, server_window, view.reg);
return wgetch ((WINDOW *) window->win);
}
static inline void
sv_draw (view_t *view)
sv_draw (view_t view)
{
sv_view_t *sv_view = view->data;
if (sv_view->draw)
sv_view->draw (view);
wnoutrefresh ((WINDOW *) sv_view->win);
sv_view_t *window = Ent_GetComponent (view.id, server_window, view.reg);
if (window->draw)
window->draw (view);
wnoutrefresh ((WINDOW *) window->win);
doupdate ();
}
static inline void
sv_setgeometry (view_t *view)
static void
sv_setgeometry (view_t view, view_pos_t foo)
{
sv_view_t *sv_view = view->data;
WINDOW *win = sv_view->win;
wresize (win, view->ylen, view->xlen);
mvwin (win, view->yabs, view->xabs);
if (sv_view->setgeometry)
sv_view->setgeometry (view);
sv_view_t *window = Ent_GetComponent (view.id, server_window, view.reg);
WINDOW *win = window->win;
view_pos_t pos = View_GetAbs (view);
view_pos_t len = View_GetLen (view);
wresize (win, len.y, len.x);
mvwin (win, pos.y, pos.x);
if (window->setgeometry)
window->setgeometry (view);
}
static void
@ -262,21 +288,20 @@ sv_complete (inputline_t *il)
Con_BasicCompleteCommandLine (il);
batch_print = 0;
sv_refresh (output);
sv_refresh (input);
doupdate ();
sv_refresh_windows ();
}
static void
draw_output (view_t *view)
draw_output (view_t view)
{
sv_view_t *sv_view = view->data;
WINDOW *win = sv_view->win;
con_buffer_t *output_buffer = sv_view->obj;
sv_view_t *window = Ent_GetComponent (view.id, server_window, view.reg);
WINDOW *win = window->win;
con_buffer_t *output_buffer = window->obj;
view_pos_t len = View_GetLen (view);
// this is not the most efficient way to update the screen, but oh well
int lines = view->ylen - 1; // leave a blank line
int width = view->xlen;
int lines = len.y - 1; // leave a blank line
int width = len.x;
int cur_line = output_buffer->line_head - 1 + view_offset;
int i, y;
@ -315,21 +340,28 @@ draw_output (view_t *view)
}
static void
draw_status (view_t *view)
draw_status (view_t view)
{
sv_view_t *sv_view = view->data;
WINDOW *win = sv_view->win;
sv_sbar_t *sb = sv_view->obj;
int i;
sv_view_t *window = Ent_GetComponent (view.id, server_window, view.reg);
WINDOW *win = window->win;
sv_sbar_t *sb = window->obj;
char *old = alloca (sb->width);
memcpy (old, sb->text, sb->width);
memset (sb->text, ' ', sb->width);
view_draw (view);
ecs_pool_t *pool = &server_reg->comp_pools[server_view];
sv_view_t *sv_view = pool->data;
for (uint32_t i = 0; i < pool->count; i++) {
view_t v = { .reg = view.reg, .id = pool->dense[i],
.comp = view.comp };
(sv_view++)->draw (v);
}
if (memcmp (old, sb->text, sb->width)) {
wbkgdset (win, COLOR_PAIR (CP_WHITE_BLUE));
wmove (win, 0, 0);
for (i = 0; i < sb->width; i++)
for (int i = 0; i < sb->width; i++)
draw_fun_char (win, sb->text[i], 1);
}
}
@ -337,9 +369,9 @@ draw_status (view_t *view)
static void
draw_input_line (inputline_t *il)
{
view_t *view = il->user_data;
sv_view_t *sv_view = view->data;
WINDOW *win = sv_view->win;
view_t view = *(view_t *) il->user_data;
sv_view_t *window = Ent_GetComponent (view.id, server_window, view.reg);
WINDOW *win = window->win;
size_t i;
const char *text;
@ -368,26 +400,28 @@ draw_input_line (inputline_t *il)
}
static void
draw_input (view_t *view)
draw_input (view_t view)
{
sv_view_t *sv_view = view->data;
draw_input_line (sv_view->obj);
sv_view_t *window = Ent_GetComponent (view.id, server_window, view.reg);
draw_input_line (window->obj);
}
static void
setgeometry_input (view_t *view)
setgeometry_input (view_t view)
{
sv_view_t *sv_view = view->data;
inputline_t *il = sv_view->obj;
il->width = view->xlen;
sv_view_t *window = Ent_GetComponent (view.id, server_window, view.reg);
view_pos_t len = View_GetLen (view);
inputline_t *il = window->obj;
il->width = len.x;
}
static void
setgeometry_status (view_t *view)
setgeometry_status (view_t view)
{
sv_view_t *sv_view = view->data;
sv_sbar_t *sb = sv_view->obj;
sb->width = view->xlen;
sv_view_t *window = Ent_GetComponent (view.id, server_window, view.reg);
sv_sbar_t *sb = window->obj;
view_pos_t len = View_GetLen (view);
sb->width = len.x;
sb->text = realloc (sb->text, sb->width);
memset (sb->text, 0, sb->width); // force an update
}
@ -427,8 +461,8 @@ process_input (void)
Sys_MaskPrintf (SYS_dev, "resizing to %d x %d\n", screen_x, screen_y);
resizeterm (screen_y, screen_x);
con_linewidth = screen_x;
view_resize (sv_con_data.view, screen_x, screen_y);
sv_con_data.view->draw (sv_con_data.view);
View_SetLen (sv_view, screen_x, screen_y);
sv_refresh_windows ();
#endif
}
@ -524,15 +558,15 @@ static void
key_event (knum_t key, short unicode, qboolean down)
{
int ovf = view_offset;
sv_view_t *sv_view;
sv_view_t *window;
con_buffer_t *buffer;
int num_lines;
switch (key) {
case QFK_PAGEUP:
view_offset -= 10;
sv_view = output->data;
buffer = sv_view->obj;
window = Ent_GetComponent (output.id, server_window, output.reg);
buffer = window->obj;
num_lines = (buffer->line_head - buffer->line_tail
+ buffer->max_lines) % buffer->max_lines;
if (view_offset <= -(num_lines - (screen_y - 3)))
@ -551,54 +585,53 @@ key_event (knum_t key, short unicode, qboolean down)
sv_draw (output);
break;
default:
sv_view = input->data;
Con_ProcessInputLine (sv_view->obj, key);
sv_refresh (input);
window = Ent_GetComponent (input.id, server_window, input.reg);
Con_ProcessInputLine (window->obj, key);
sv_refresh_windows ();
break;
}
doupdate ();
}
static void
print (char *txt)
{
sv_view_t *sv_view = output->data;
Con_BufferAddText (sv_view->obj, txt);
sv_view_t *window = Ent_GetComponent (output.id, server_window,
output.reg);
Con_BufferAddText (window->obj, txt);
if (!view_offset) {
while (*txt)
draw_fun_char (sv_view->win, (byte) *txt++, 0);
draw_fun_char (window->win, (byte) *txt++, 0);
if (!batch_print) {
sv_refresh (output);
doupdate ();
sv_refresh_windows ();
}
}
}
static view_t *
create_window (view_t *parent, int xpos, int ypos, int xlen, int ylen,
grav_t grav, void *obj, int opts, void (*draw) (view_t *),
void (*setgeometry) (view_t *))
static view_t
create_window (view_t parent, int xpos, int ypos, int xlen, int ylen,
grav_t grav, void *obj, int opts, void (*draw) (view_t),
void (*setgeometry) (view_t))
{
view_t *view;
sv_view_t *sv_view;
view_t view = View_New (server_reg, parent);
View_SetPos (view, xpos, ypos);
View_SetLen (view, xlen, ylen);
View_SetGravity (view, grav);
View_SetResize (view, !!(opts & sv_resize_x), !!(opts & sv_resize_y));
View_SetOnResize (view, sv_setgeometry);
View_SetOnMove (view, sv_setgeometry);
sv_view = calloc (1, sizeof (sv_view_t));
sv_view->obj = obj;
sv_view->win = newwin (ylen, xlen, 0, 0); // will get moved when added
scrollok (sv_view->win, (opts & sv_scroll) ? TRUE : FALSE);
leaveok (sv_view->win, (opts & sv_cursor) ? FALSE : TRUE);
nodelay (sv_view->win, TRUE);
keypad (sv_view->win, TRUE);
sv_view->draw = draw;
sv_view->setgeometry = setgeometry;
sv_view_t window = {
.obj = obj,
.win = newwin (ylen, xlen, 0, 0), // will get moved when updated
.draw = draw,
.setgeometry = setgeometry,
};
Ent_SetComponent (view.id, server_window, view.reg, &window);
view = view_new (xpos, ypos, xlen, ylen, grav);
view->data = sv_view;
view->draw = sv_draw;
view->setgeometry = sv_setgeometry;
view->resize_x = (opts & sv_resize_x) != 0;
view->resize_y = (opts & sv_resize_y) != 0;
view_add (parent, view);
scrollok (window.win, (opts & sv_scroll) ? TRUE : FALSE);
leaveok (window.win, (opts & sv_cursor) ? FALSE : TRUE);
nodelay (window.win, TRUE);
keypad (window.win, TRUE);
return view;
}
@ -610,14 +643,14 @@ exec_line (inputline_t *il)
}
static inputline_t *
create_input_line (int width)
create_input_line (int width, view_t *view)
{
inputline_t *input_line;
input_line = Con_CreateInputLine (16, MAXCMDLINE, ']');
input_line->complete = sv_complete;
input_line->enter = exec_line;
input_line->user_data = input;
input_line->user_data = view;
input_line->draw = draw_input_line;
input_line->width = width;
@ -640,28 +673,37 @@ init (void)
nonl ();
get_size (&screen_x, &screen_y);
sv_con_data.view = view_new (0, 0, screen_x, screen_y, grav_northwest);
server_reg = ECS_NewRegistry ();
ECS_RegisterComponents (server_reg, server_components, server_comp_count);
server_reg->href_comp = server_href;
output = create_window (sv_con_data.view,
get_size (&screen_x, &screen_y);
sv_view = View_New (server_reg, nullview);
View_SetPos (sv_view, 0, 0);
View_SetLen (sv_view, screen_x, screen_y);
View_SetGravity (sv_view, grav_northwest);
output = create_window (sv_view,
0, 0, screen_x, screen_y - 2, grav_northwest,
Con_CreateBuffer (BUFFER_SIZE, MAX_LINES),
sv_resize_x | sv_resize_y | sv_scroll,
draw_output, 0);
status = create_window (sv_con_data.view,
status = create_window (sv_view,
0, 1, screen_x, 1, grav_southwest,
calloc (1, sizeof (sv_sbar_t)),
sv_resize_x,
draw_status, setgeometry_status);
sv_con_data.status_view = status;
sv_con_data.status_view = &status;
input = create_window (sv_con_data.view,
input = create_window (sv_view,
0, 0, screen_x, 1, grav_southwest,
create_input_line (screen_x),
create_input_line (screen_x, &input),
sv_resize_x | sv_cursor,
draw_input, setgeometry_input);
((inputline_t *) ((sv_view_t *) input->data)->obj)->user_data = input;
View_UpdateHierarchy (sv_view);
init_pair (CP_YELLOW_BLACK, COLOR_YELLOW, COLOR_BLACK);
init_pair (CP_GREEN_BLACK, COLOR_GREEN, COLOR_BLACK);
@ -678,7 +720,6 @@ init (void)
con_linewidth = screen_x;
sv_con_data.view->draw (sv_con_data.view);
wrefresh (curscr);
}
#endif
@ -799,8 +840,8 @@ C_DrawConsole (void)
{
// only the status bar is drawn because the inputline and output views
// take care of themselves
if (sv_con_data.status_view)
sv_con_data.status_view->draw (sv_con_data.status_view);
draw_status (status);
sv_refresh_windows ();
}
static void

12
libs/ui/test/Makemodule.am
View file

@ -1,13 +1,17 @@
libs_ui_tests = \
libs/ui/test/test-flow \
libs/ui/test/test-flow-size \
libs/ui/test/test-passage \
libs/ui/test/test-txtbuffer \
libs/ui/test/test-vrect
TESTS += $(libs_ui_tests)
libs_ui_xfail_tests = \
libs/ui/test/test-flow \
libs/ui/test/test-flow-size
check_PROGRAMS += $(libs_ui_tests)
TESTS += $(libs_ui_tests) $(libs_ui_xfail_tests)
XFAIL_TESTS += $(libs_ui_xfail_tests)
check_PROGRAMS += $(libs_ui_tests) $(libs_ui_xfail_tests)
libs_ui_test_test_flow_SOURCES=libs/ui/test/test-flow.c
libs_ui_test_test_flow_LDADD=libs/ui/libQFui.la

10
libs/ui/test/test-flow-size.c
View file

@ -4,7 +4,7 @@
#include <stdio.h>
#include "QF/ui/view.h"
#if 0
typedef struct {
struct {
int xlen, ylen;
@ -283,3 +283,11 @@ main (void)
}
return ret;
}
#endif
int
main (void)
{
printf ("FIXME: redo for ECS\n");
return 1;
}

10
libs/ui/test/test-flow.c
View file

@ -4,7 +4,7 @@
#include <stdio.h>
#include "QF/ui/view.h"
#if 0
typedef struct {
struct {
int xlen, ylen;
@ -282,3 +282,11 @@ main (void)
}
return ret;
}
#endif
int
main (void)
{
printf ("FIXME: redo for ECS\n");
return 1;
}

208
libs/ui/view.c
View file

@ -41,6 +41,8 @@
#include "QF/cexpr.h"
#include "QF/mathlib.h"
#define IMPLEMENT_VIEW_Funcs
#include "QF/ui/view.h"
static exprenum_t grav_t_enum;
@ -81,6 +83,211 @@ static exprenum_t grav_t_enum = {
&grav_t_symtab,
};
static void
view_modified_init (void *_modified)
{
byte *modified = _modified;
*modified = 1;
}
static const component_t view_components[view_type_count] = {
[view_pos] = {
.size = sizeof (view_pos_t),
.name = "pos",
},
[view_len] = {
.size = sizeof (view_pos_t),
.name = "len",
},
[view_abs] = {
.size = sizeof (view_pos_t),
.name = "abs",
},
[view_rel] = {
.size = sizeof (view_pos_t),
.name = "rel",
},
[view_oldlen] = {
.size = sizeof (view_pos_t),
.name = "oldlen",
},
[view_control] = {
.size = sizeof (viewcont_t),
.name = "control",
},
[view_modified] = {
.size = sizeof (byte),
.create = view_modified_init,
.name = "modified",
},
[view_onresize] = {
.size = sizeof (view_resize_f),
.name = "onresize",
},
[view_onmove] = {
.size = sizeof (view_move_f),
.name = "onmove",
},
};
static const hierarchy_type_t view_type = {
.num_components = view_type_count,
.components = view_components,
};
view_t
View_New (ecs_registry_t *reg, view_t parent)
{
uint32_t view = ECS_NewEntity (reg);
hierref_t *ref = Ent_AddComponent (view, reg->href_comp, reg);
if (parent.reg && parent.id != nullent) {
hierref_t *pref = View_GetRef (parent);
ref->hierarchy = pref->hierarchy;
ref->index = Hierarchy_InsertHierarchy (pref->hierarchy, 0,
pref->index, 0);
} else {
ref->hierarchy = Hierarchy_New (reg, &view_type, 1);
ref->index = 0;
}
ref->hierarchy->ent[ref->index] = view;
return (view_t) { .reg = reg, .id = view, .comp = reg->href_comp };
}
void
View_UpdateHierarchy (view_t view)
{
__auto_type ref = View_GetRef (view);
hierarchy_t *h = ref->hierarchy;
byte *modified = h->components[view_modified];
view_pos_t *pos = h->components[view_pos];
view_pos_t *len = h->components[view_len];
view_pos_t *abs = h->components[view_abs];
view_pos_t *rel = h->components[view_rel];
view_pos_t *oldlen = h->components[view_oldlen];
viewcont_t *cont = h->components[view_control];
view_resize_f *onresize = h->components[view_onresize];
view_resize_f *onmove = h->components[view_onmove];
uint32_t *parent = h->parentIndex;
uint32_t *id = h->ent;
if (abs[0].x != pos[0].x || abs[0].y != pos[0].y) {
modified[0] = 1;
abs[0] = pos[0];
rel[0] = pos[0];
}
for (uint32_t i = 1; i < h->num_objects; i++) {
uint32_t par = parent[i];
if (!(modified[i] & 2) && (modified[par] & 2)
&& (cont[i].resize_x || cont[i].resize_y)) {
int dx = len[par].x - oldlen[par].x;
int dy = len[par].y - oldlen[par].y;
if (cont[i].resize_x) {
len[i].x += dx;
}
if (cont[i].resize_y) {
len[i].y += dy;
}
modified[i] |= 2;
}
if (modified[i] || modified[par]) {
switch (cont[i].gravity) {
case grav_center:
rel[i].x = pos[i].x + (len[par].x - len[i].x) / 2;
rel[i].y = pos[i].y + (len[par].y - len[i].y) / 2;
break;
case grav_north:
rel[i].x = pos[i].x + (len[par].x - len[i].x) / 2;
rel[i].y = pos[i].y;
break;
case grav_northeast:
rel[i].x = len[par].x - pos[i].x - len[i].x;
rel[i].y = pos[i].y;
break;
case grav_east:
rel[i].x = len[par].x - pos[i].x - len[i].x;
rel[i].y = pos[i].y + (len[par].y - len[i].y) / 2;
break;
case grav_southeast:
rel[i].x = len[par].x - pos[i].x - len[i].x;
rel[i].y = len[par].y - pos[i].y - len[i].y;
break;
case grav_south:
rel[i].x = pos[i].x + (len[par].x - len[i].x) / 2;
rel[i].y = len[par].y - pos[i].y - len[i].y;
break;
case grav_southwest:
rel[i].x = pos[i].x;
rel[i].y = len[par].y - pos[i].y - len[i].y;
break;
case grav_west:
rel[i].x = pos[i].x;
rel[i].y = pos[i].y + (len[par].y - len[i].y) / 2;
break;
case grav_northwest:
rel[i].x = pos[i].x;
rel[i].y = pos[i].y;
break;
case grav_flow:
break;
}
abs[i].x = abs[par].x + rel[i].x;
abs[i].y = abs[par].y + rel[i].y;
}
}
for (uint32_t i = 0; i < h->num_objects; i++) {
if ((modified[i] & 2) && onresize[i]) {
view_t v = { .reg = view.reg, .id = id[i], .comp = view.comp };
onresize[i] (v, len[i]);
}
if (modified[i] & 2) {
oldlen[i] = len[i];
}
if ((modified[i] & 1) && onmove[i]) {
view_t v = { .reg = view.reg, .id = id[i], .comp = view.comp };
onresize[i] (v, abs[i]);
}
modified[i] = 0;
}
}
void
View_SetParent (view_t view, view_t parent)
{
if (parent.reg && parent.id != nullent) {
__auto_type ref = View_GetRef (view);
__auto_type vref = *ref;
__auto_type pref = View_GetRef (parent);
ref->index = Hierarchy_InsertHierarchy (pref->hierarchy,
vref.hierarchy,
pref->index, vref.index);
ref->hierarchy = pref->hierarchy;
Hierarchy_RemoveHierarchy (vref.hierarchy, vref.index);
if (!vref.hierarchy->num_objects) {
Hierarchy_Delete (vref.hierarchy);
}
} else {
__auto_type ref = View_GetRef (view);
__auto_type vref = *ref;
if (!vref.index) {
return;
}
ref->hierarchy = Hierarchy_New (view.reg, &view_type, 0);
Hierarchy_InsertHierarchy (ref->hierarchy, vref.hierarchy, nullent,
vref.index);
Hierarchy_RemoveHierarchy (vref.hierarchy, vref.index);
if (!vref.hierarchy->num_objects) {
Hierarchy_Delete (vref.hierarchy);
}
}
__auto_type ref = View_GetRef (view);
hierarchy_t *h = ref->hierarchy;
byte *modified = h->components[view_modified];
modified[ref->index] = 1;
View_UpdateHierarchy (view);
}
#if 0
static void
setgeometry (view_t *view)
{
@ -525,3 +732,4 @@ view_flow_up_left (view_t *view)
{
flow_up (view, set_columns_left);
}
#endif

11
libs/video/renderer/r_graph.c
View file

@ -50,7 +50,7 @@ int graphval;
Performance monitoring tool
*/
void
R_TimeGraph (view_t *view)
R_TimeGraph (view_pos_t abs)
{
static int timex;
int a;
@ -78,14 +78,14 @@ R_TimeGraph (view_t *view)
a = 0;
}
memcpy (timings + o, r_timings + a, l * sizeof (timings[0]));
r_funcs->R_LineGraph (view->xabs, view->yabs, r_timings,
MAX_TIMINGS, 200);//r_data->graphheight->int_val);
r_funcs->R_LineGraph (abs.x, abs.y, r_timings, MAX_TIMINGS, 200);
//r_data->graphheight->int_val);
timex = (timex + 1) % MAX_TIMINGS;
}
void
R_ZGraph (view_t *view)
R_ZGraph (view_pos_t abs)
{
int w;
static int height[256];
@ -97,6 +97,5 @@ R_ZGraph (view_t *view)
height[r_framecount & 255] = ((int) r_refdef.frame.position[2]) & 31;
r_funcs->R_LineGraph (view->xabs, view->yabs, height,
w, *r_data->graphheight);
r_funcs->R_LineGraph (abs.x, abs.y, height, w, *r_data->graphheight);
}

11
libs/video/renderer/r_screen.c
View file

@ -174,13 +174,8 @@ SCR_SetFOV (float fov)
static void
SCR_CalcRefdef (void)
{
view_t *view = r_data->scr_view;
const vrect_t *rect = &r_data->refdef->vrect;
r_data->vid->recalc_refdef = 0;
view_setgeometry (view, rect->x, rect->y, rect->width, rect->height);
// force a background redraw
r_data->scr_fullupdate = 0;
r_funcs->bind_framebuffer (0);
@ -317,7 +312,7 @@ SCR_UpdateScreen (transform_t camera, double realtime, SCR_Func *scr_funcs)
}
}
r_funcs->set_2d (0);
view_draw (r_data->scr_view);
//view_draw (r_data->scr_view);
r_funcs->set_2d (1);
while (*scr_funcs) {
(*scr_funcs) ();
@ -453,8 +448,8 @@ vidsize_listener (void *data, const viddef_t *vdef)
void
SCR_Init (void)
{
r_data->scr_view->xlen = r_data->vid->width;
r_data->scr_view->ylen = r_data->vid->height;
//r_data->scr_view->xlen = r_data->vid->width;
//r_data->scr_view->ylen = r_data->vid->height;
// register our commands
Cmd_AddCommand ("screenshot", ScreenShot_f, "Take a screenshot, "

1
libs/video/renderer/r_text.c
View file

@ -46,6 +46,7 @@ RText_NewShaper (rfont_t *font)
rshaper_t *shaper = malloc (sizeof (rshaper_t));
shaper->rfont = font;
shaper->font = hb_ft_font_create (font->face, 0);
hb_ft_font_set_funcs (shaper->font);
shaper->buffer = hb_buffer_create ();
shaper->features = (r_hb_featureset_t) DARRAY_STATIC_INIT (4);

8
libs/video/renderer/sw/d_scan.c
View file

@ -53,10 +53,10 @@ D_WarpScreen (framebuffer_t *src)
sw_framebuffer_t *buffer = src->buffer;
int w, h;
int u, v;
int scr_x = vr_data.scr_view->xpos;
int scr_y = vr_data.scr_view->ypos;
int scr_w = vr_data.scr_view->xlen;
int scr_h = vr_data.scr_view->ylen;
int scr_x = vr_data.refdef->vrect.x;
int scr_y = vr_data.refdef->vrect.y;
int scr_w = vr_data.refdef->vrect.width;
int scr_h = vr_data.refdef->vrect.height;
byte *dest;
int *turb;
int *col;

2
libs/video/renderer/vid_common.c
View file

@ -39,12 +39,10 @@
#include "r_internal.h"
viddef_t vid; // global video state
view_t scr_view;
vid_render_data_t vid_render_data = {
.vid = &vid,
.refdef = &r_refdef,
.scr_view = &scr_view,
.scr_copytop = 0,
.scr_copyeverything = 0,
.scr_fullupdate = 0,

8
libs/video/renderer/vid_render_sw.c
View file

@ -208,10 +208,10 @@ sw_end_frame (void)
vrect.height = vid.height - vr_data.lineadj;
vrect.next = 0;
} else {
vrect.x = vr_data.scr_view->xpos;
vrect.y = vr_data.scr_view->ypos;
vrect.width = vr_data.scr_view->xlen;
vrect.height = vr_data.scr_view->ylen;
vrect.x = vr_data.refdef->vrect.x;
vrect.y = vr_data.refdef->vrect.y;
vrect.width = vr_data.refdef->vrect.width;
vrect.height = vr_data.refdef->vrect.height;
vrect.next = 0;
}
sw_ctx->update (sw_ctx, &vrect);

2
nq/include/client.h
View file

@ -289,7 +289,7 @@ extern qboolean recording;
struct cvar_s;
void Cvar_Info (void *data, const struct cvar_s *cvar);
extern struct view_s *cl_screen_view;
extern struct view_s cl_screen_view;
void CL_Init_Screen (void);
void CL_UpdateScreen (double realtime);

22
nq/source/cl_parse.c
View file

@ -583,11 +583,11 @@ CL_ParseClientdata (void)
i = MSG_ReadLong (net_message);
if (cl.stats[STAT_ITEMS] != i) { // set flash times
Sbar_Changed ();
for (j = 0; j < 32; j++)
if ((i & (1 << j)) && !(cl.stats[STAT_ITEMS] & (1 << j)))
cl.item_gettime[j] = cl.time;
cl.stats[STAT_ITEMS] = i;
Sbar_Changed (sbc_items);
#define IT_POWER (IT_QUAD | IT_SUIT | IT_INVULNERABILITY | IT_INVISIBILITY)
cl.viewstate.powerup_index = (cl.stats[STAT_ITEMS] & IT_POWER) >> 19;
}
@ -607,7 +607,7 @@ CL_ParseClientdata (void)
i = 0;
if (cl.stats[STAT_ARMOR] != i) {
cl.stats[STAT_ARMOR] = i;
Sbar_Changed ();
Sbar_Changed (sbc_armor);
}
if (bits & SU_WEAPON)
@ -616,27 +616,27 @@ CL_ParseClientdata (void)
i = 0;
if (cl.stats[STAT_WEAPON] != i) {
cl.stats[STAT_WEAPON] = i;
Sbar_Changed ();
cl.viewstate.weapon_model = cl_world.models.a[cl.stats[STAT_WEAPON]];
Sbar_Changed (sbc_weapon);
}
i = (short) MSG_ReadShort (net_message);
if (cl.stats[STAT_HEALTH] != i) {
cl.stats[STAT_HEALTH] = i;
Sbar_Changed ();
Sbar_Changed (sbc_health);
}
i = MSG_ReadByte (net_message);
if (cl.stats[STAT_AMMO] != i) {
cl.stats[STAT_AMMO] = i;
Sbar_Changed ();
Sbar_Changed (sbc_ammo);
}
for (i = 0; i < 4; i++) {
j = MSG_ReadByte (net_message);
if (cl.stats[STAT_SHELLS + i] != j) {
cl.stats[STAT_SHELLS + i] = j;
Sbar_Changed ();
Sbar_Changed (sbc_ammo);
}
}
@ -645,13 +645,13 @@ CL_ParseClientdata (void)
if (standard_quake) {
if (cl.stats[STAT_ACTIVEWEAPON] != i) {
cl.stats[STAT_ACTIVEWEAPON] = i;
Sbar_Changed ();
Sbar_Changed (sbc_weapon);
}
} else {
// hipnotic/rogue weapon "bit field" (stupid idea)
if (cl.stats[STAT_ACTIVEWEAPON] != (1 << i)) {
cl.stats[STAT_ACTIVEWEAPON] = (1 << i);
Sbar_Changed ();
Sbar_Changed (sbc_weapon);
}
}
@ -872,7 +872,7 @@ CL_ParseServerMessage (void)
break;
case svc_updatename:
Sbar_Changed ();
Sbar_Changed (sbc_info);
i = MSG_ReadByte (net_message);
if (i >= cl.maxclients)
Host_Error ("CL_ParseServerMessage: svc_updatename > "
@ -882,7 +882,7 @@ CL_ParseServerMessage (void)
break;
case svc_updatefrags:
Sbar_Changed ();
Sbar_Changed (sbc_frags);
i = MSG_ReadByte (net_message);
if (i >= cl.maxclients)
Host_Error ("CL_ParseServerMessage: svc_updatefrags > "
@ -900,7 +900,7 @@ CL_ParseServerMessage (void)
break;
case svc_updatecolors:
Sbar_Changed ();
Sbar_Changed (sbc_info);
i = MSG_ReadByte (net_message);
if (i >= cl.maxclients) {
Host_Error ("CL_ParseServerMessage: svc_updatecolors > "

200
nq/source/cl_screen.c
View file

@ -55,6 +55,7 @@
#include "r_local.h" //FIXME for r_cache_thrash
#include "client/hud.h"
#include "client/world.h"
#include "nq/include/client.h"
@ -87,27 +88,14 @@ static cvar_t scr_showturtle_cvar = {
.value = { .type = &cexpr_int, .value = &scr_showturtle },
};
view_t *cl_screen_view;
static view_t *net_view;
static view_t *timegraph_view;
static view_t *zgraph_view;
static view_t *loading_view;
static qpic_t *scr_ram;
static qpic_t *scr_turtle;
static void
draw_pic (view_t *view)
{
r_funcs->Draw_Pic (view->xabs, view->yabs, view->data);
}
static void
draw_cachepic (view_t *view)
{
qpic_t *pic = r_funcs->Draw_CachePic (view->data, 1);
r_funcs->Draw_Pic (view->xabs, view->yabs, pic);
}
view_t cl_screen_view;
static view_t net_view;
static view_t timegraph_view;
static view_t zgraph_view;
static view_t loading_view;
static view_t ram_view;
static view_t turtle_view;
static view_t pause_view;
static void
SCR_CShift (void)
@ -125,75 +113,36 @@ SCR_CShift (void)
r_funcs->Draw_BlendScreen (cl.viewstate.cshift_color);
}
static void
SCR_DrawRam (void)
{
if (!scr_showram)
return;
if (!r_cache_thrash)
return;
r_funcs->Draw_Pic (cl_screen_view->xpos + 32, cl_screen_view->ypos,
scr_ram);
}
static void
SCR_DrawTurtle (void)
{
static int count;
if (!scr_showturtle)
return;
if (r_data->frametime < 0.1) {
count = 0;
return;
}
count++;
if (count < 3)
return;
r_funcs->Draw_Pic (cl_screen_view->xpos, cl_screen_view->ypos,
scr_turtle);
}
static void
SCR_DrawPause (void)
{
qpic_t *pic;
if (!scr_showpause) // turn off for screenshots
return;
if (!r_data->paused)
return;
pic = r_funcs->Draw_CachePic ("gfx/pause.lmp", true);
r_funcs->Draw_Pic ((cl_screen_view->xlen - pic->width) / 2,
(cl_screen_view->ylen - 48 - pic->height) / 2,
pic);
}
static void
scr_draw_views (void)
{
net_view->visible = (!cls.demoplayback
&& realtime - cl.last_servermessage >= 0.3);
loading_view->visible = cl.loading;
timegraph_view->visible = r_timegraph;
zgraph_view->visible = r_zgraph;
if (scr_showturtle) {
static int count;
if (r_data->frametime < 0.1) {
count = 0;
} else {
count++;
}
View_SetVisible (turtle_view, count > 2);
}
// turn off for screenshots
View_SetVisible (pause_view, scr_showpause && r_data->paused);
View_SetVisible (ram_view, scr_showram && r_cache_thrash);
View_SetVisible (net_view,
(!cls.demoplayback && realtime - cl.last_servermessage >= 0.3));
View_SetVisible (loading_view, cl.loading);
// FIXME cvar callbacks
View_SetVisible (timegraph_view, r_timegraph);
View_SetVisible (zgraph_view, r_zgraph);
view_draw (cl_screen_view);
}
static SCR_Func scr_funcs_normal[] = {
0, //Draw_Crosshair,
SCR_DrawRam,
SCR_DrawTurtle,
SCR_DrawPause,
Sbar_Draw,
HUD_Draw_Views,
SCR_CShift,
Sbar_DrawCenterPrint,
scr_draw_views,
@ -219,45 +168,90 @@ static SCR_Func *scr_funcs[] = {
scr_funcs_finale,
};
static void
cl_vidsize_listener (void *data, const viddef_t *vdef)
{
View_SetLen (cl_screen_view, vdef->width, vdef->height);
View_UpdateHierarchy (cl_screen_view);
}
void
CL_Init_Screen (void)
{
qpic_t *pic;
cl_screen_view = r_data->scr_view;
con_module->data->console->screen_view = cl_screen_view;
VID_OnVidResize_AddListener (cl_vidsize_listener, 0);
scr_ram = r_funcs->Draw_PicFromWad ("ram");
scr_turtle = r_funcs->Draw_PicFromWad ("turtle");
HUD_Init ();
cl_screen_view = View_New (hud_registry, nullview);
con_module->data->console->screen_view = &cl_screen_view;
View_SetPos (cl_screen_view, 0, 0);
View_SetLen (cl_screen_view, viddef.width, viddef.height);
View_SetGravity (cl_screen_view, grav_northwest);
View_SetVisible (cl_screen_view, 1);
pic = r_funcs->Draw_PicFromWad ("ram");
ram_view = View_New (hud_registry, cl_screen_view);
View_SetPos (ram_view, 32, 0);
View_SetLen (ram_view, pic->width, pic->height);
View_SetGravity (ram_view, grav_northwest);
Ent_SetComponent (ram_view.id, hud_pic, ram_view.reg, &pic);
View_SetVisible (ram_view, 0);
pic = r_funcs->Draw_PicFromWad ("turtle");
turtle_view = View_New (hud_registry, cl_screen_view);
View_SetPos (turtle_view, 32, 0);
View_SetLen (turtle_view, pic->width, pic->height);
View_SetGravity (turtle_view, grav_northwest);
Ent_SetComponent (turtle_view.id, hud_pic, turtle_view.reg, &pic);
View_SetVisible (turtle_view, 0);
Cvar_Register (&scr_showpause_cvar, 0, 0);
Cvar_Register (&scr_showram_cvar, 0, 0);
Cvar_Register (&scr_showturtle_cvar, 0, 0);
pic = r_funcs->Draw_PicFromWad ("net");
net_view = view_new (64, 0, pic->width, pic->height, grav_northwest);
net_view->draw = draw_pic;
net_view->data = pic;
net_view->visible = 0;
view_add (cl_screen_view, net_view);
net_view = View_New (hud_registry, cl_screen_view);
View_SetPos (net_view, 64, 0);
View_SetLen (net_view, pic->width, pic->height);
View_SetGravity (net_view, grav_northwest);
Ent_SetComponent (net_view.id, hud_pic, net_view.reg, &pic);
View_SetVisible (net_view, 0);
timegraph_view = view_new (0, 0, cl_screen_view->xlen, 100, grav_southwest);
timegraph_view->draw = R_TimeGraph;
timegraph_view->visible = 0;
view_add (cl_screen_view, timegraph_view);
timegraph_view = View_New (hud_registry, cl_screen_view);
View_SetPos (timegraph_view, 0, 0);
View_SetLen (timegraph_view, r_data->vid->width, 100);
View_SetGravity (timegraph_view, grav_southwest);
Ent_SetComponent (timegraph_view.id, hud_func, timegraph_view.reg,
R_TimeGraph);
View_SetVisible (timegraph_view, r_timegraph);
zgraph_view = view_new (0, 0, cl_screen_view->xlen, 100, grav_southwest);
zgraph_view->draw = R_ZGraph;
zgraph_view->visible = 0;
view_add (cl_screen_view, zgraph_view);
zgraph_view = View_New (hud_registry, cl_screen_view);
View_SetPos (zgraph_view, 0, 0);
View_SetLen (zgraph_view, r_data->vid->width, 100);
View_SetGravity (zgraph_view, grav_southwest);
Ent_SetComponent (zgraph_view.id, hud_func, zgraph_view.reg, R_ZGraph);
View_SetVisible (zgraph_view, r_zgraph);
const char *name = "gfx/loading.lmp";
pic = r_funcs->Draw_CachePic (name, 1);
loading_view = view_new (0, -24, pic->width, pic->height, grav_center);
loading_view->draw = draw_cachepic;
loading_view->data = (void *) name;
loading_view->visible = 0;
view_add (cl_screen_view, loading_view);
loading_view = View_New (hud_registry, cl_screen_view);
View_SetPos (loading_view, 0, -24);
View_SetLen (loading_view, pic->width, pic->height);
View_SetGravity (loading_view, grav_center);
Ent_SetComponent (loading_view.id, hud_cachepic, loading_view.reg, &name);
View_SetVisible (loading_view, 0);
name = "gfx/pause.lmp";
pic = r_funcs->Draw_CachePic (name, 1);
pause_view = View_New (hud_registry, cl_screen_view);
View_SetPos (pause_view, 0, -24);
View_SetLen (pause_view, pic->width, pic->height);
View_SetGravity (pause_view, grav_center);
Ent_SetComponent (pause_view.id, hud_cachepic, pause_view.reg, &name);
View_SetVisible (pause_view, 0);
}
void

658
nq/source/sbar.c
View file

File diff suppressed because it is too large Load diff

46
qtv/source/sbar.c
View file

@ -45,50 +45,62 @@
#include "qtv/include/qtv.h"
static void
draw_clients (view_t *view)
draw_clients (view_t view)
{
sv_view_t *sv_view = view->data;
sv_view_t *sv_view = Ent_GetComponent (view.id, server_view, view.reg);
sv_sbar_t *sb = sv_view->obj;
view_pos_t rel = View_GetRel (view);
const char *str;
const char *s;
char *d;
str = va (0, "[CL: %3d]", client_count);
for (s = str, d = sb->text + view->xrel; *s; s++)
for (s = str, d = sb->text + rel.x; *s; s++)
*d++ = *s;
}
static void
draw_servers (view_t *view)
draw_servers (view_t view)
{
sv_view_t *sv_view = view->data;
sv_view_t *sv_view = Ent_GetComponent (view.id, server_view, view.reg);
sv_sbar_t *sb = sv_view->obj;
view_pos_t rel = View_GetRel (view);
const char *str;
const char *s;
char *d;
str = va (0, "[SV: %2d]", server_count);
for (s = str, d = sb->text + view->xrel; *s; s++)
for (s = str, d = sb->text + rel.x; *s; s++)
*d++ = *s;
}
void
qtv_sbar_init (void)
{
view_t *status;
view_t *view;
view_t status;
view_t view;
if (!con_module || !con_module->data->console->status_view)
return;
status = con_module->data->console->status_view;
view = view_new (0, 0, 8, 1, grav_northwest);
view->draw = draw_servers;
view->data = status->data;
view_add (status, view);
status = *con_module->data->console->status_view;
void *comp = Ent_GetComponent (status.id, server_window, status.reg);
sv_view_t sv_view = *(sv_view_t *) comp;
sv_view.setgeometry = 0;
view = view_new (8, 0, 9, 1, grav_northwest);
view->draw = draw_clients;
view->data = status->data;
view_add (status, view);
view = View_New (status.reg, status);
View_SetPos (view, 0, 0);
View_SetLen (view, 8, 1);
View_SetGravity (view, grav_northwest);
sv_view.draw = draw_servers;
Ent_SetComponent (view.id, server_view, view.reg, &sv_view);
view = View_New (status.reg, status);
View_SetPos (view, 8, 0);
View_SetLen (view, 9, 1);
View_SetGravity (view, grav_northwest);
sv_view.draw = draw_clients;
Ent_SetComponent (view.id, server_view, view.reg, &sv_view);
View_UpdateHierarchy (status);
}

6
qw/include/client.h
View file

@ -297,11 +297,11 @@ extern struct cbuf_s *cl_stbuf;
struct cvar_s;
void Cvar_Info (void *data, const struct cvar_s *cvar);
extern struct view_s *cl_netgraph_view;
void CL_NetGraph (struct view_s *view);
extern struct view_s cl_netgraph_view;
void CL_NetGraph (struct view_s view);
void CL_NetGraph_Init_Cvars (void);
extern struct view_s *cl_screen_view;
extern struct view_s cl_screen_view;
void CL_Init_Screen (void);
void CL_UpdateScreen (double realtime);

4
qw/source/cl_cam.c
View file

@ -199,7 +199,7 @@ Cam_Unlock (void)
}
autocam = CAM_NONE;
locked = false;
Sbar_Changed ();
Sbar_Changed (~0);
}
}
@ -221,7 +221,7 @@ Cam_Lock (int playernum)
last_lock = realtime;
cam_forceview = true;
locked = false;
Sbar_Changed ();
Sbar_Changed (~0);
}
static trace_t

40
qw/source/cl_ngraph.c
View file

@ -84,13 +84,13 @@ static cvar_t cl_netgraph_height_cvar = {
.flags = CVAR_ARCHIVE,
.value = { .type = &cexpr_int, .value = &cl_netgraph_height },
};
view_t *cl_netgraph_view;
view_t cl_netgraph_view;
static void
cl_netgraph_f (void *data, const cvar_t *cvar)
{
if (cl_netgraph_view) {
cl_netgraph_view->visible = cl_netgraph != 0;
if (View_Valid (cl_netgraph_view)) {
View_SetVisible (cl_netgraph_view, cl_netgraph != 0);
}
}
@ -98,34 +98,34 @@ static void
cl_netgraph_height_f (void *data, const cvar_t *cvar)
{
cl_netgraph_height = max (32, cl_netgraph_height);
if (cl_netgraph_view) {
view_resize (cl_netgraph_view, cl_netgraph_view->xlen,
cl_netgraph_height + 25);
if (View_Valid (cl_netgraph_view)) {
view_pos_t len = View_GetLen (cl_netgraph_view);
View_SetLen (cl_netgraph_view, len.x, cl_netgraph_height + 25);
View_UpdateHierarchy (cl_netgraph_view);
}
}
void
CL_NetGraph (view_t *view)
CL_NetGraph (view_t view)
{
int lost, a, l, x, y, i, o;
int timings[NET_TIMINGS];
x = view->xabs;
y = view->yabs;
view_pos_t abs = View_GetAbs (view);
view_pos_t len = View_GetLen (view);
if (cl_netgraph_box) {
r_funcs->Draw_TextBox (x, y, NET_TIMINGS / 8,
r_funcs->Draw_TextBox (abs.x, abs.y, NET_TIMINGS / 8,
cl_netgraph_height / 8 + 1,
cl_netgraph_alpha * 255);
}
lost = CL_CalcNet ();
x = view->xabs + 8;
y = view->yabs + view->ylen - 9;
x = abs.x + 8;
y = abs.y + len.y - 9;
l = NET_TIMINGS;
if (l > view->xlen - 8)
l = view->xlen - 8;
if (l > len.x - 8)
l = len.x - 8;
i = cls.netchan.outgoing_sequence & NET_TIMINGSMASK;
a = i - l;
o = 0;
@ -140,9 +140,15 @@ CL_NetGraph (view_t *view)
r_funcs->R_LineGraph (x, y, timings,
NET_TIMINGS, cl_netgraph_height);
x = view->xabs + 8;
y = view->yabs + 8;
x = abs.x + 8;
y = abs.y + 8;
r_funcs->Draw_String (x, y, va (0, "%3i%% packet loss", lost));
/*
//FIXME don't do every frame
view_move (cl_netgraph_view, cl_netgraph_view->xpos, hud_sb_lines);
view_setgravity (cl_netgraph_view,
hud_swap ? grav_southeast : grav_southwest);
*/
}
void

8
qw/source/cl_parse.c
View file

@ -1031,7 +1031,7 @@ CL_ProcessUserInfo (int slot, player_info_t *player)
player->skinname->value);
player->skin = mod_funcs->Skin_SetColormap (player->skin, slot + 1);
Sbar_Changed ();
Sbar_Changed (sbc_info);
}
static void
@ -1150,13 +1150,13 @@ CL_SetStat (int stat, int value)
return;
}
Sbar_Changed ();
Sbar_Changed (~0);
switch (stat) {
case STAT_ITEMS:
Sbar_Changed ();
#define IT_POWER (IT_QUAD | IT_SUIT | IT_INVULNERABILITY | IT_INVISIBILITY)
cl.viewstate.powerup_index = (cl.stats[STAT_ITEMS]&IT_POWER) >> 19;
Sbar_Changed (sbc_items);
break;
case STAT_HEALTH:
if (cl_player_health_e->func)
@ -1378,12 +1378,12 @@ CL_ParseServerMessage (void)
// svc_updatename
case svc_updatefrags:
Sbar_Changed ();
i = MSG_ReadByte (net_message);
if (i >= MAX_CLIENTS)
Host_Error ("CL_ParseServerMessage: svc_updatefrags > "
"MAX_SCOREBOARD");
cl.players[i].frags = (short) MSG_ReadShort (net_message);
Sbar_Changed (sbc_frags);
break;
// svc_clientdata

207
qw/source/cl_screen.c
View file

@ -90,25 +90,14 @@ static cvar_t scr_showturtle_cvar = {
.value = { .type = &cexpr_int, .value = &scr_showturtle },
};
view_t *cl_screen_view;
static view_t *net_view;
static view_t *loading_view;
static qpic_t *scr_ram;
static qpic_t *scr_turtle;
static void
draw_pic (view_t *view)
{
r_funcs->Draw_Pic (view->xabs, view->yabs, view->data);
}
static void
draw_cachepic (view_t *view)
{
qpic_t *pic = r_funcs->Draw_CachePic (view->data, 1);
r_funcs->Draw_Pic (view->xabs, view->yabs, pic);
}
view_t cl_screen_view;
static view_t net_view;
static view_t timegraph_view;
static view_t zgraph_view;
static view_t loading_view;
static view_t ram_view;
static view_t turtle_view;
static view_t pause_view;
static void
SCR_CShift (void)
@ -126,84 +115,35 @@ SCR_CShift (void)
r_funcs->Draw_BlendScreen (cl.viewstate.cshift_color);
}
static void
SCR_DrawRam (void)
{
if (!scr_showram)
return;
if (!r_cache_thrash)
return;
r_funcs->Draw_Pic (cl_screen_view->xpos + 32, cl_screen_view->ypos,
scr_ram);
}
static void
SCR_DrawTurtle (void)
{
static int count;
if (!scr_showturtle)
return;
if (r_data->frametime < 0.1) {
count = 0;
return;
}
count++;
if (count < 3)
return;
r_funcs->Draw_Pic (cl_screen_view->xpos, cl_screen_view->ypos,
scr_turtle);
}
static void
SCR_DrawPause (void)
{
qpic_t *pic;
if (!scr_showpause) // turn off for screenshots
return;
if (!r_data->paused)
return;
pic = r_funcs->Draw_CachePic ("gfx/pause.lmp", true);
r_funcs->Draw_Pic ((cl_screen_view->xlen - pic->width) / 2,
(cl_screen_view->ylen - 48 - pic->height) / 2,
pic);
}
static void
scr_draw_views (void)
{
net_view->visible = (!cls.demoplayback
&& (cls.netchan.outgoing_sequence
- cls.netchan.incoming_acknowledged)
>= UPDATE_BACKUP - 1);
loading_view->visible = cl.loading;
cl_netgraph_view->visible = cl_netgraph != 0;
if (scr_showturtle) {
static int count;
if (r_data->frametime < 0.1) {
count = 0;
} else {
count++;
}
View_SetVisible (turtle_view, count > 2);
}
//FIXME don't do every frame
view_move (cl_netgraph_view, cl_netgraph_view->xpos, hud_sb_lines);
view_setgravity (cl_netgraph_view,
hud_swap ? grav_southeast : grav_southwest);
// turn off for screenshots
View_SetVisible (pause_view, scr_showpause && r_data->paused);
view_draw (cl_screen_view);
View_SetVisible (ram_view, scr_showram && r_cache_thrash);
View_SetVisible (net_view,
(!cls.demoplayback && realtime - cl.last_servermessage >= 0.3));
View_SetVisible (loading_view, cl.loading);
}
static SCR_Func scr_funcs_normal[] = {
0, //Draw_Crosshair,
SCR_DrawRam,
SCR_DrawTurtle,
SCR_DrawPause,
Sbar_Draw,
HUD_Draw_Views,
SCR_CShift,
scr_draw_views,
Sbar_DrawCenterPrint,
scr_draw_views,
Con_DrawConsole,
0
};
@ -228,43 +168,98 @@ static SCR_Func *scr_funcs[] = {
scr_funcs_finale,
};
static void
cl_vidsize_listener (void *data, const viddef_t *vdef)
{
View_SetLen (cl_screen_view, vdef->width, vdef->height);
View_UpdateHierarchy (cl_screen_view);
}
void
CL_Init_Screen (void)
{
qpic_t *pic;
cl_screen_view = r_data->scr_view;
con_module->data->console->screen_view = cl_screen_view;
VID_OnVidResize_AddListener (cl_vidsize_listener, 0);
scr_ram = r_funcs->Draw_PicFromWad ("ram");
scr_turtle = r_funcs->Draw_PicFromWad ("turtle");
HUD_Init ();
cl_screen_view = View_New (hud_registry, nullview);
con_module->data->console->screen_view = &cl_screen_view;
View_SetPos (cl_screen_view, 0, 0);
View_SetLen (cl_screen_view, viddef.width, viddef.height);
View_SetGravity (cl_screen_view, grav_northwest);
View_SetVisible (cl_screen_view, 1);
pic = r_funcs->Draw_PicFromWad ("ram");
ram_view = View_New (hud_registry, cl_screen_view);
View_SetPos (ram_view, 32, 0);
View_SetLen (ram_view, pic->width, pic->height);
View_SetGravity (ram_view, grav_northwest);
Ent_SetComponent (ram_view.id, hud_pic, ram_view.reg, &pic);
View_SetVisible (ram_view, 0);
pic = r_funcs->Draw_PicFromWad ("turtle");
turtle_view = View_New (hud_registry, cl_screen_view);
View_SetPos (turtle_view, 32, 0);
View_SetLen (turtle_view, pic->width, pic->height);
View_SetGravity (turtle_view, grav_northwest);
Ent_SetComponent (turtle_view.id, hud_pic, turtle_view.reg, &pic);
View_SetVisible (turtle_view, 0);
Cvar_Register (&scr_showpause_cvar, 0, 0);
Cvar_Register (&scr_showram_cvar, 0, 0);
Cvar_Register (&scr_showturtle_cvar, 0, 0);
pic = r_funcs->Draw_PicFromWad ("net");
net_view = view_new (64, 0, pic->width, pic->height, grav_northwest);
net_view->draw = draw_pic;
net_view->data = pic;
net_view->visible = 0;
view_add (cl_screen_view, net_view);
net_view = View_New (hud_registry, cl_screen_view);
View_SetPos (net_view, 64, 0);
View_SetLen (net_view, pic->width, pic->height);
View_SetGravity (net_view, grav_northwest);
Ent_SetComponent (net_view.id, hud_pic, net_view.reg, &pic);
View_SetVisible (net_view, 0);
timegraph_view = View_New (hud_registry, cl_screen_view);
View_SetPos (timegraph_view, 0, 0);
View_SetLen (timegraph_view, r_data->vid->width, 100);
View_SetGravity (timegraph_view, grav_southwest);
Ent_SetComponent (timegraph_view.id, hud_func, timegraph_view.reg,
R_TimeGraph);
View_SetVisible (timegraph_view, r_timegraph);
zgraph_view = View_New (hud_registry, cl_screen_view);
View_SetPos (zgraph_view, 0, 0);
View_SetLen (zgraph_view, r_data->vid->width, 100);
View_SetGravity (zgraph_view, grav_southwest);
Ent_SetComponent (zgraph_view.id, hud_func, zgraph_view.reg, R_ZGraph);
View_SetVisible (zgraph_view, r_zgraph);
const char *name = "gfx/loading.lmp";
pic = r_funcs->Draw_CachePic (name, 1);
loading_view = view_new (0, -24, pic->width, pic->height, grav_center);
loading_view->draw = draw_cachepic;
loading_view->data = (void *) name;
loading_view->visible = 0;
view_add (cl_screen_view, loading_view);
loading_view = View_New (hud_registry, cl_screen_view);
View_SetPos (loading_view, 0, -24);
View_SetLen (loading_view, pic->width, pic->height);
View_SetGravity (loading_view, grav_center);
Ent_SetComponent (loading_view.id, hud_cachepic, loading_view.reg, &name);
View_SetVisible (loading_view, 0);
cl_netgraph_view = view_new (0, hud_sb_lines,
NET_TIMINGS + 16,
cl_netgraph_height + 25,
grav_southwest);
cl_netgraph_view->draw = CL_NetGraph;
cl_netgraph_view->visible = 0;
view_add (cl_screen_view, cl_netgraph_view);
name = "gfx/pause.lmp";
pic = r_funcs->Draw_CachePic (name, 1);
pause_view = View_New (hud_registry, cl_screen_view);
View_SetPos (pause_view, 0, -24);
View_SetLen (pause_view, pic->width, pic->height);
View_SetGravity (pause_view, grav_center);
Ent_SetComponent (pause_view.id, hud_cachepic, pause_view.reg, &name);
View_SetVisible (pause_view, 0);
cl_netgraph_view = View_New (hud_registry, cl_screen_view);
View_SetPos (cl_netgraph_view, 0, hud_sb_lines);
View_SetLen (cl_netgraph_view, NET_TIMINGS + 16, cl_netgraph_height + 25);
View_SetGravity (cl_netgraph_view, grav_southwest);
Ent_SetComponent (cl_netgraph_view.id, hud_func, cl_netgraph_view.reg,
CL_NetGraph);
View_SetVisible (cl_netgraph_view, cl_netgraph);
}
void

545
qw/source/sbar.c
View file

File diff suppressed because it is too large Load diff

65
qw/source/sv_sbar.c
View file

@ -45,10 +45,11 @@
#include "qw/include/sv_recorder.h"
static void
draw_cpu (view_t *view)
draw_cpu (view_t view)
{
sv_view_t *sv_view = view->data;
sv_view_t *sv_view = Ent_GetComponent (view.id, server_view, view.reg);
sv_sbar_t *sb = sv_view->obj;
view_pos_t rel = View_GetRel (view);
double cpu;
const char *cpu_str;
const char *s;
@ -58,34 +59,36 @@ draw_cpu (view_t *view)
cpu = 100 * svs.stats.latched_active / cpu;
cpu_str = va (0, "[CPU: %3d%%]", (int) cpu);
for (s = cpu_str, d = sb->text + view->xrel; *s; s++)
for (s = cpu_str, d = sb->text + rel.x; *s; s++)
*d++ = *s;
if (cpu > 70.0) {
int i;
for (i = 6; i < 9; i++)
sb->text[view->xrel + i] |= 0x80;
sb->text[rel.x + i] |= 0x80;
}
}
static void
draw_rec (view_t *view)
draw_rec (view_t view)
{
sv_view_t *sv_view = view->data;
sv_view_t *sv_view = Ent_GetComponent (view.id, server_view, view.reg);
sv_sbar_t *sb = sv_view->obj;
view_pos_t rel = View_GetRel (view);
const char *str;
const char *s;
char *d;
str = va (0, "[REC: %d]", SVR_NumRecorders ());
for (s = str, d = sb->text + view->xrel; *s; s++)
for (s = str, d = sb->text + rel.x; *s; s++)
*d++ = *s;
}
static void
draw_mem (view_t *view)
draw_mem (view_t view)
{
sv_view_t *sv_view = view->data;
sv_view_t *sv_view = Ent_GetComponent (view.id, server_view, view.reg);
sv_sbar_t *sb = sv_view->obj;
view_pos_t rel = View_GetRel (view);
const char *str;
const char *s;
char *d;
@ -97,32 +100,44 @@ draw_mem (view_t *view)
if (used / (size / 256) >= 192) {
mask = 0x80;
}
for (s = str, d = sb->text + view->xrel; *s; s++)
for (s = str, d = sb->text + rel.x; *s; s++)
*d++ = *s | mask;
}
void
SV_Sbar_Init (void)
{
view_t *status;
view_t *view;
view_t status;
view_t view;
if (!con_module || !con_module->data->console->status_view)
return;
status = con_module->data->console->status_view;
view = view_new (0, 0, 11, 1, grav_northwest);
view->draw = draw_cpu;
view->data = status->data;
view_add (status, view);
status = *con_module->data->console->status_view;
void *comp = Ent_GetComponent (status.id, server_window, status.reg);
sv_view_t sv_view = *(sv_view_t *) comp;
sv_view.setgeometry = 0;
view = view_new (11, 0, 8, 1, grav_northwest);
view->draw = draw_rec;
view->data = status->data;
view_add (status, view);
view = View_New (status.reg, status);
View_SetPos (view, 0, 0);
View_SetLen (view, 11, 1);
View_SetGravity (view, grav_northwest);
sv_view.draw = draw_cpu;
Ent_SetComponent (view.id, server_view, view.reg, &sv_view);
view = view_new (19, 0, 18, 1, grav_northwest);
view->draw = draw_mem;
view->data = status->data;
view_add (status, view);
view = View_New (status.reg, status);
View_SetPos (view, 11, 0);
View_SetLen (view, 8, 1);
View_SetGravity (view, grav_northwest);
sv_view.draw = draw_rec;
Ent_SetComponent (view.id, server_view, view.reg, &sv_view);
view = View_New (status.reg, status);
View_SetPos (view, 19, 0);
View_SetLen (view, 18, 1);
View_SetGravity (view, grav_northwest);
sv_view.draw = draw_mem;
Ent_SetComponent (view.id, server_view, view.reg, &sv_view);
View_UpdateHierarchy (status);
}