qf/quakeforge
0
0
Fork 0
mirror of https://git.code.sf.net/p/quake/quakeforge synced 2024-11-13 08:27:39 +00:00
Code Issues Projects Releases Packages Wiki Activity
quakeforge/qw/source/cl_screen.c
Bill Currie 4578b1af0d [vid] Remove console view from viddef_t 
This breaks console scaling for now (con_width and con_height are gone),
but is a major step towards window resize support as console stuff
should never have been in viddef_t in the first place.

The client screen init code now sets up a screen view (actually the
renderer's scr_view) that is passed to the client console so it can know
the size of the screen. The same view is used by the status bar code.

Also, the ram/cache/paused icon drawing is moved into the client screen
update code. A bit of duplication, but I do plan on merging that
eventually.
2022-09-21 17:31:18 +09:00

307 lines
6.9 KiB
C
Raw Blame History

/*
cl_screen.c
master for refresh, status bar, console, chat, notify, etc
Copyright (C) 1996-1997 Id Software, Inc.
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to:
Free Software Foundation, Inc.
59 Temple Place - Suite 330
Boston, MA 02111-1307, USA
*/
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
#ifdef HAVE_STRING_H
# include <string.h>
#endif
#ifdef HAVE_STRINGS_H
# include <strings.h>
#endif
#include <time.h>
#include "QF/console.h"
#include "QF/cvar.h"
#include "QF/draw.h"
#include "QF/image.h"
#include "QF/pcx.h"
#include "QF/screen.h"
#include "QF/plugin/console.h"
#include "QF/scene/scene.h"
#include "QF/scene/transform.h"
#include "QF/ui/view.h"
#include "sbar.h"
#include "r_local.h" //FIXME for r_cache_thrash
#include "client/hud.h"
#include "client/view.h"
#include "client/world.h"
#include "qw/include/client.h"
#include "qw/include/cl_parse.h"
int scr_showpause;
static cvar_t scr_showpause_cvar = {
.name = "showpause",
.description =
"Toggles display of pause graphic",
.default_value = "1",
.flags = CVAR_NONE,
.value = { .type = &cexpr_int, .value = &scr_showpause },
};
int scr_showram;
static cvar_t scr_showram_cvar = {
.name = "showram",
.description =
"Show RAM icon if game is running low on memory",
.default_value = "1",
.flags = CVAR_NONE,
.value = { .type = &cexpr_int, .value = &scr_showram },
};
int scr_showturtle;
static cvar_t scr_showturtle_cvar = {
.name = "showturtle",
.description =
"Show a turtle icon if your fps is below 10",
.default_value = "0",
.flags = CVAR_NONE,
.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);
}
static void
SCR_CShift (void)
{
mleaf_t *leaf;
int contents = CONTENTS_EMPTY;
if (cls.state == ca_active && cl_world.scene->worldmodel) {
vec4f_t origin;
origin = Transform_GetWorldPosition (cl.viewstate.camera_transform);
leaf = Mod_PointInLeaf (origin, cl_world.scene->worldmodel);
contents = leaf->contents;
}
V_SetContentsColor (&cl.viewstate, contents);
r_funcs->Draw_BlendScreen (cl.viewstate.cshift_color);
}
static void
SCR_DrawRam (void)
{
if (!scr_showram)
return;
if (!r_cache_thrash)
return;
//FIXME view
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;
//FIXME view
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;
//FIXME view conwidth
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;
//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);
view_draw (cl_screen_view);
}
static SCR_Func scr_funcs_normal[] = {
0, //Draw_Crosshair,
SCR_DrawRam,
SCR_DrawTurtle,
SCR_DrawPause,
Sbar_Draw,
SCR_CShift,
scr_draw_views,
Sbar_DrawCenterPrint,
Con_DrawConsole,
0
};
static SCR_Func scr_funcs_intermission[] = {
Sbar_IntermissionOverlay,
Con_DrawConsole,
scr_draw_views,
0
};
static SCR_Func scr_funcs_finale[] = {
Sbar_FinaleOverlay,
Con_DrawConsole,
scr_draw_views,
0,
};
static SCR_Func *scr_funcs[] = {
scr_funcs_normal,
scr_funcs_intermission,
scr_funcs_finale,
};
void
CL_Init_Screen (void)
{
qpic_t *pic;
cl_screen_view = r_data->scr_view;
con_module->data->console->screen_view = cl_screen_view;
scr_ram = r_funcs->Draw_PicFromWad ("ram");
scr_turtle = r_funcs->Draw_PicFromWad ("turtle");
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);
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);
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);
}
void
CL_UpdateScreen (double realtime)
{
unsigned index = cl.intermission;
if (index >= sizeof (scr_funcs) / sizeof (scr_funcs[0]))
index = 0;
//FIXME not every time
if (cls.state == ca_active) {
if (cl.watervis)
r_data->min_wateralpha = 0.0;
else
r_data->min_wateralpha = 1.0;
}
scr_funcs_normal[0] = r_funcs->Draw_Crosshair;
if (cl.viewstate.flags & VF_GIB) {
cl.viewstate.height = 8; // gib view height
} else if (cl.viewstate.flags & VF_DEAD) {
cl.viewstate.height = -16; // corpse view height
} else {
cl.viewstate.height = DEFAULT_VIEWHEIGHT; // view height
if (cl.stdver)
cl.viewstate.height = cl.stats[STAT_VIEWHEIGHT];
}
cl.viewstate.intermission = cl.intermission != 0;
V_PrepBlend (&cl.viewstate);
int seq = (cls.netchan.outgoing_sequence - 1) & UPDATE_MASK;
frame_t *frame = &cl.frames[seq];
cl.viewstate.movecmd[FORWARD] = frame->cmd.forwardmove;
V_RenderView (&cl.viewstate);
SCR_UpdateScreen (cl.viewstate.camera_transform,
realtime, scr_funcs[index]);
}
Reference in a new issue View git blame Copy permalink