screen.h File Reference

Go to the source code of this file.

Functions
void	SCR_Init (void)
void	SCR_UpdateScreen (void)
void	SCR_SizeUp (void)
void	SCR_SizeDown (void)
void	SCR_CenterPrint (char *str)
void	SCR_BeginLoadingPlaque (void)
void	SCR_EndLoadingPlaque (void)
void	SCR_DebugGraph (float value, int color)
void	SCR_TouchPics (void)
void	SCR_RunConsole (void)
void	SCR_AddDirtyPoint (int x, int y)
void	SCR_DirtyScreen (void)
void	SCR_PlayCinematic (char *name)
qboolean	SCR_DrawCinematic (void)
void	SCR_RunCinematic (void)
void	SCR_StopCinematic (void)
void	SCR_FinishCinematic (void)

Variables
float	scr_con_current
float	scr_conlines
int	sb_lines
cvar_t *	scr_viewsize
cvar_t *	crosshair
vrect_t	scr_vrect
char	crosshair_pic [MAX_QPATH]
int	crosshair_width
int	crosshair_height

Function Documentation

SCR_AddDirtyPoint()

void SCR_AddDirtyPoint	(	int	x,
		int	y
	)

Definition at line 675 of file cl_scrn.c.

{
    if (x < scr_dirty.x1)
        scr_dirty.x1 = x;
    if (x > scr_dirty.x2)
        scr_dirty.x2 = x;
    if (y < scr_dirty.y1)
        scr_dirty.y1 = y;
    if (y > scr_dirty.y2)
        scr_dirty.y2 = y;
}

Referenced by CL_PrepRefresh(), Con_DrawConsole(), Con_DrawNotify(), SCR_DirtyScreen(), SCR_DrawCenterString(), SCR_DrawField(), SCR_ExecuteLayoutString(), and V_RenderView().

SCR_BeginLoadingPlaque()

void SCR_BeginLoadingPlaque

(

void

)

Definition at line 571 of file cl_scrn.c.

{
    S_StopAllSounds ();
    cl.sound_prepped = false;       // don't play ambients
    CDAudio_Stop ();
    if (cls.disable_screen)
        return;
    if (developer->value)
        return;
    if (cls.state == ca_disconnected)
        return; // if at console, don't bring up the plaque
    if (cls.key_dest == key_console)
        return;
    if (cl.cinematictime > 0)
        scr_draw_loading = 2;   // clear to balack first
    else
        scr_draw_loading = 1;
    SCR_UpdateScreen ();
    cls.disable_screen = Sys_Milliseconds ();
    cls.disable_servercount = cl.servercount;
}

Referenced by SCR_Loading_f().

SCR_CenterPrint()

void SCR_CenterPrint

(

char *

str

)

Definition at line 203 of file cl_scrn.c.

{
    char    *s;
    char    line[64];
    int     i, j, l;
 
    strncpy (scr_centerstring, str, sizeof(scr_centerstring)-1);
    scr_centertime_off = scr_centertime->value;
    scr_centertime_start = cl.time;
 
    // count the number of lines for centering
    scr_center_lines = 1;
    s = str;
    while (*s)
    {
        if (*s == '\n')
            scr_center_lines++;
        s++;
    }
 
    // echo it to the console
    Com_Printf("\n\n\35\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\37\n\n");
 
    s = str;
    do  
    {
    // scan the width of the line
        for (l=0 ; l<40 ; l++)
            if (s[l] == '\n' || !s[l])
                break;
        for (i=0 ; i<(40-l)/2 ; i++)
            line[i] = ' ';
 
        for (j=0 ; j<l ; j++)
        {
            line[i++] = s[j];
        }
 
        line[i] = '\n';
        line[i+1] = 0;
 
        Com_Printf ("%s", line);
 
        while (*s && *s != '\n')
            s++;
 
        if (!*s)
            break;
        s++;        // skip the \n
    } while (1);
    Com_Printf("\n\n\35\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\37\n\n");
    Con_ClearNotify ();
}

Referenced by CL_ParseServerMessage().

SCR_DebugGraph()

void SCR_DebugGraph	(	float	value,
		int	color
	)

Definition at line 139 of file cl_scrn.c.

{
    values[current&1023].value = value;
    values[current&1023].color = color;
    current++;
}

SCR_DirtyScreen()

void SCR_DirtyScreen

(

void

)

Definition at line 687 of file cl_scrn.c.

{
    SCR_AddDirtyPoint (0, 0);
    SCR_AddDirtyPoint (viddef.width-1, viddef.height-1);
}

Referenced by CL_DrawInventory(), M_Draw(), MainWndProc(), and SCR_TileClear().

SCR_DrawCinematic()

qboolean SCR_DrawCinematic

(

void

)

Definition at line 541 of file cl_cin.c.

{
    if (cl.cinematictime <= 0)
    {
        return false;
    }
 
    if (cls.key_dest == key_menu)
    {   // blank screen and pause if menu is up
        re.CinematicSetPalette(NULL);
        cl.cinematicpalette_active = false;
        return true;
    }
 
    if (!cl.cinematicpalette_active)
    {
        re.CinematicSetPalette(cl.cinematicpalette);
        cl.cinematicpalette_active = true;
    }
 
    if (!cin.pic)
        return true;
 
    re.DrawStretchRaw (0, 0, viddef.width, viddef.height,
        cin.width, cin.height, cin.pic);
 
    return true;
}

Referenced by SCR_UpdateScreen().

SCR_EndLoadingPlaque()

void SCR_EndLoadingPlaque

(

void

)

Definition at line 598 of file cl_scrn.c.

{
    cls.disable_screen = 0;
    Con_ClearNotify ();
}

SCR_FinishCinematic()

void SCR_FinishCinematic

(

void

)

Definition at line 198 of file cl_cin.c.

{
    // tell the server to advance to the next map / cinematic
    MSG_WriteByte (&cls.netchan.message, clc_stringcmd);
    SZ_Print (&cls.netchan.message, va("nextserver %i\n", cl.servercount));
}

Referenced by CL_SendCmd(), SCR_PlayCinematic(), and SCR_RunCinematic().

SCR_Init()

void SCR_Init

(

void

)

Definition at line 419 of file cl_scrn.c.

{
    scr_viewsize = Cvar_Get ("viewsize", "100", CVAR_ARCHIVE);
    scr_conspeed = Cvar_Get ("scr_conspeed", "3", 0);
    scr_showturtle = Cvar_Get ("scr_showturtle", "0", 0);
    scr_showpause = Cvar_Get ("scr_showpause", "1", 0);
    scr_centertime = Cvar_Get ("scr_centertime", "2.5", 0);
    scr_printspeed = Cvar_Get ("scr_printspeed", "8", 0);
    scr_netgraph = Cvar_Get ("netgraph", "0", 0);
    scr_timegraph = Cvar_Get ("timegraph", "0", 0);
    scr_debuggraph = Cvar_Get ("debuggraph", "0", 0);
    scr_graphheight = Cvar_Get ("graphheight", "32", 0);
    scr_graphscale = Cvar_Get ("graphscale", "1", 0);
    scr_graphshift = Cvar_Get ("graphshift", "0", 0);
    scr_drawall = Cvar_Get ("scr_drawall", "0", 0);
 
//
// register our commands
//
    Cmd_AddCommand ("timerefresh",SCR_TimeRefresh_f);
    Cmd_AddCommand ("loading",SCR_Loading_f);
    Cmd_AddCommand ("sizeup",SCR_SizeUp_f);
    Cmd_AddCommand ("sizedown",SCR_SizeDown_f);
    Cmd_AddCommand ("sky",SCR_Sky_f);
 
    scr_initialized = true;
}

Referenced by CL_Init().

SCR_PlayCinematic()

void SCR_PlayCinematic

(

char *

name

)

Definition at line 576 of file cl_cin.c.

{
    int     width, height;
    byte    *palette;
    char    name[MAX_OSPATH], *dot;
    int     old_khz;
 
    // make sure CD isn't playing music
    CDAudio_Stop();
 
    cl.cinematicframe = 0;
    dot = strstr (arg, ".");
    if (dot && !strcmp (dot, ".pcx"))
    {   // static pcx image
        Com_sprintf (name, sizeof(name), "pics/%s", arg);
        SCR_LoadPCX (name, &cin.pic, &palette, &cin.width, &cin.height);
        cl.cinematicframe = -1;
        cl.cinematictime = 1;
        SCR_EndLoadingPlaque ();
        cls.state = ca_active;
        if (!cin.pic)
        {
            Com_Printf ("%s not found.\n", name);
            cl.cinematictime = 0;
        }
        else
        {
            memcpy (cl.cinematicpalette, palette, sizeof(cl.cinematicpalette));
            Z_Free (palette);
        }
        return;
    }
 
    Com_sprintf (name, sizeof(name), "video/%s", arg);
    FS_FOpenFile (name, &cl.cinematic_file);
    if (!cl.cinematic_file)
    {
//      Com_Error (ERR_DROP, "Cinematic %s not found.\n", name);
        SCR_FinishCinematic ();
        cl.cinematictime = 0;   // done
        return;
    }
 
    SCR_EndLoadingPlaque ();
 
    cls.state = ca_active;
 
    FS_Read (&width, 4, cl.cinematic_file);
    FS_Read (&height, 4, cl.cinematic_file);
    cin.width = LittleLong(width);
    cin.height = LittleLong(height);
 
    FS_Read (&cin.s_rate, 4, cl.cinematic_file);
    cin.s_rate = LittleLong(cin.s_rate);
    FS_Read (&cin.s_width, 4, cl.cinematic_file);
    cin.s_width = LittleLong(cin.s_width);
    FS_Read (&cin.s_channels, 4, cl.cinematic_file);
    cin.s_channels = LittleLong(cin.s_channels);
 
    Huff1TableInit ();
 
    // switch up to 22 khz sound if necessary
    old_khz = Cvar_VariableValue ("s_khz");
    if (old_khz != cin.s_rate/1000)
    {
        cin.restart_sound = true;
        Cvar_SetValue ("s_khz", cin.s_rate/1000);
        CL_Snd_Restart_f ();
        Cvar_SetValue ("s_khz", old_khz);
    }
 
    cl.cinematicframe = 0;
    cin.pic = SCR_ReadNextFrame ();
    cl.cinematictime = Sys_Milliseconds ();
}

Referenced by CL_ParseServerData().

SCR_RunCinematic()

void SCR_RunCinematic

(

void

)

Definition at line 490 of file cl_cin.c.

{
    int     frame;
 
    if (cl.cinematictime <= 0)
    {
        SCR_StopCinematic ();
        return;
    }
 
    if (cl.cinematicframe == -1)
        return;     // static image
 
    if (cls.key_dest != key_game)
    {   // pause if menu or console is up
        cl.cinematictime = cls.realtime - cl.cinematicframe*1000/14;
        return;
    }
 
    frame = (cls.realtime - cl.cinematictime)*14.0/1000;
    if (frame <= cl.cinematicframe)
        return;
    if (frame > cl.cinematicframe+1)
    {
        Com_Printf ("Dropped frame: %i > %i\n", frame, cl.cinematicframe+1);
        cl.cinematictime = cls.realtime - cl.cinematicframe*1000/14;
    }
    if (cin.pic)
        Z_Free (cin.pic);
    cin.pic = cin.pic_pending;
    cin.pic_pending = NULL;
    cin.pic_pending = SCR_ReadNextFrame ();
    if (!cin.pic_pending)
    {
        SCR_StopCinematic ();
        SCR_FinishCinematic ();
        cl.cinematictime = 1;   // hack to get the black screen behind loading
        SCR_BeginLoadingPlaque ();
        cl.cinematictime = 0;
        return;
    }
}

Referenced by CL_Frame().

SCR_RunConsole()

void SCR_RunConsole

(

void

)

Definition at line 507 of file cl_scrn.c.

{
// decide on the height of the console
    if (cls.key_dest == key_console)
        scr_conlines = 0.5;     // half screen
    else
        scr_conlines = 0;               // none visible
    
    if (scr_conlines < scr_con_current)
    {
        scr_con_current -= scr_conspeed->value*cls.frametime;
        if (scr_conlines > scr_con_current)
            scr_con_current = scr_conlines;
 
    }
    else if (scr_conlines > scr_con_current)
    {
        scr_con_current += scr_conspeed->value*cls.frametime;
        if (scr_conlines < scr_con_current)
            scr_con_current = scr_conlines;
    }
 
}

Referenced by CL_Frame().

SCR_SizeDown()

void SCR_SizeDown

(

void

)

SCR_SizeUp()

void SCR_SizeUp

(

void

)

SCR_StopCinematic()

void SCR_StopCinematic

(

void

)

Definition at line 153 of file cl_cin.c.

{
    cl.cinematictime = 0;   // done
    if (cin.pic)
    {
        Z_Free (cin.pic);
        cin.pic = NULL;
    }
    if (cin.pic_pending)
    {
        Z_Free (cin.pic_pending);
        cin.pic_pending = NULL;
    }
    if (cl.cinematicpalette_active)
    {
        re.CinematicSetPalette(NULL);
        cl.cinematicpalette_active = false;
    }
    if (cl.cinematic_file)
    {
        fclose (cl.cinematic_file);
        cl.cinematic_file = NULL;
    }
    if (cin.hnodes1)
    {
        Z_Free (cin.hnodes1);
        cin.hnodes1 = NULL;
    }
 
    // switch back down to 11 khz sound if necessary
    if (cin.restart_sound)
    {
        cin.restart_sound = false;
        CL_Snd_Restart_f ();
    }
 
}

Referenced by CL_Disconnect(), and SCR_RunCinematic().

SCR_TouchPics()

void SCR_TouchPics

(

void

)

Definition at line 928 of file cl_scrn.c.

{
    int     i, j;
 
    for (i=0 ; i<2 ; i++)
        for (j=0 ; j<11 ; j++)
            re.RegisterPic (sb_nums[i][j]);
 
    if (crosshair->value)
    {
#ifdef QMAX
      if (crosshair->value > 9)
        crosshair->value = 9;
#else
      if (crosshair->value > 3 || crosshair->value < 0)
        crosshair->value = 3;
#endif    
      Com_sprintf (crosshair_pic, sizeof(crosshair_pic), "ch%i", (int)(crosshair->value));
      re.DrawGetPicSize (&crosshair_width, &crosshair_height, crosshair_pic);
      if (!crosshair_width)
        crosshair_pic[0] = 0;
    
    }
}

Referenced by CL_PrepRefresh(), and SCR_DrawCrosshair().

SCR_UpdateScreen()

void SCR_UpdateScreen

(

void

)

Definition at line 1285 of file cl_scrn.c.

{
    int numframes;
    int i;
    float separation[2] = { 0, 0 };
 
    // if the screen is disabled (loading plaque is up, or vid mode changing)
    // do nothing at all
    if (cls.disable_screen)
    {
        if (Sys_Milliseconds() - cls.disable_screen > 120000)
        {
            cls.disable_screen = 0;
            Com_Printf ("Loading plaque timed out.\n");
        }
        return;
    }
 
    if (!scr_initialized || !con.initialized)
        return;             // not initialized yet
 
    /*
    ** range check cl_camera_separation so we don't inadvertently fry someone's
    ** brain
    */
#ifdef REDBLUE
    if ( cl_stereo_separation->value > 10.0 )
        Cvar_SetValue( "cl_stereo_separation", 10.0 );
#else
    if ( cl_stereo_separation->value > 1.0 )
        Cvar_SetValue( "cl_stereo_separation", 1.0 );
#endif
    else if ( cl_stereo_separation->value < 0 )
        Cvar_SetValue( "cl_stereo_separation", 0.0 );
 
#ifdef REDBLUE
    if ( !cl_stereo->value )
      Cvar_SetValue( "cl_stereo", 1 );
 
    numframes = 2;
    separation[0] = -cl_stereo_separation->value / 2.0;
    separation[1] =  cl_stereo_separation->value / 2.0;
#else
    if ( cl_stereo->value )
    {
        numframes = 2;
        separation[0] = -cl_stereo_separation->value / 2;
        separation[1] =  cl_stereo_separation->value / 2;
    }       
    else
    {
        separation[0] = 0;
        separation[1] = 0;
        numframes = 1;
    }
#endif
    for ( i = 0; i < numframes; i++ )
    {
      re.BeginFrame( separation[i] );
      
      if (scr_draw_loading == 2)
        {   //  loading plaque over black screen
          int       w, h;
          
          re.CinematicSetPalette(NULL);
          scr_draw_loading = false;
          re.DrawGetPicSize (&w, &h, "loading");
          re.DrawPic ((viddef.width-w)/2, (viddef.height-h)/2, "loading");
          //            re.EndFrame();
          //            return;
        } 
      // if a cinematic is supposed to be running, handle menus
      // and console specially
      else if (cl.cinematictime > 0)
        {
          if (cls.key_dest == key_menu)
        {
          if (cl.cinematicpalette_active)
            {
              re.CinematicSetPalette(NULL);
              cl.cinematicpalette_active = false;
            }
          M_Draw ();
          //                re.EndFrame();
          //                return;
        }
          else if (cls.key_dest == key_console)
        {
          if (cl.cinematicpalette_active)
            {
              re.CinematicSetPalette(NULL);
              cl.cinematicpalette_active = false;
            }
          SCR_DrawConsole ();
          //                re.EndFrame();
          //                return;
        }
          else
        {
          SCR_DrawCinematic();
          //                re.EndFrame();
          //                return;
        }
        }
      else 
        {
          
          // make sure the game palette is active
          if (cl.cinematicpalette_active)
        {
          re.CinematicSetPalette(NULL);
          cl.cinematicpalette_active = false;
        }
          
          // do 3D refresh drawing, and then update the screen
          SCR_CalcVrect ();
          
          // clear any dirty part of the background
          SCR_TileClear ();
          
          V_RenderView ( separation[i] );
          
          SCR_DrawStats ();
          if (cl.frame.playerstate.stats[STAT_LAYOUTS] & 1)
        SCR_DrawLayout ();
          if (cl.frame.playerstate.stats[STAT_LAYOUTS] & 2)
        CL_DrawInventory ();
          
          SCR_DrawNet ();
          SCR_CheckDrawCenterString ();
          
          // FPS counter hack 
          // http://www.quakesrc.org/?Page=tutorials&What=./tutorials/Quake2/misc/fps.txt
          if (cl_drawfps->value) {
        char s[8];
        sprintf(s,"%3.0ffps", 1/cls.frametime);
        DrawString(viddef.width-64,0,s);
          }
          
          if (scr_timegraph->value)
        SCR_DebugGraph (cls.frametime*300, 0);
          
          if (scr_debuggraph->value || scr_timegraph->value || scr_netgraph->value)
        SCR_DrawDebugGraph ();
          
          SCR_DrawPause ();
          
          SCR_DrawConsole ();
          
          M_Draw ();
          
          SCR_DrawLoading ();
        }
    }
    re.EndFrame();
}

Referenced by CL_Frame(), CL_PrepRefresh(), CL_Skins_f(), Key_Console(), and SCR_BeginLoadingPlaque().

Variable Documentation

crosshair

cvar_t* crosshair

Definition at line 33 of file cl_view.c.

Referenced by ControlsSetMenuItemValues(), SCR_DrawCrosshair(), SCR_TouchPics(), and V_Init().

crosshair_height

int crosshair_height

Definition at line 49 of file screen.h.

crosshair_pic

char crosshair_pic[MAX_QPATH]

Definition at line 69 of file cl_scrn.c.

Referenced by SCR_DrawCrosshair(), and SCR_TouchPics().

crosshair_width

int crosshair_width

Definition at line 70 of file cl_scrn.c.

Referenced by SCR_DrawCrosshair(), and SCR_TouchPics().

sb_lines

int sb_lines

scr_con_current

float scr_con_current

Definition at line 37 of file cl_scrn.c.

Referenced by SCR_DrawConsole(), SCR_RunConsole(), and SCR_TileClear().

scr_conlines

float scr_conlines

Definition at line 38 of file cl_scrn.c.

Referenced by SCR_RunConsole().

scr_viewsize

cvar_t* scr_viewsize

Definition at line 47 of file cl_scrn.c.

Referenced by SCR_CalcVrect(), SCR_Init(), SCR_SizeDown_f(), SCR_SizeUp_f(), and SCR_TileClear().

scr_vrect

vrect_t scr_vrect

Definition at line 44 of file cl_scrn.c.

Referenced by SCR_CalcVrect(), SCR_DrawCrosshair(), SCR_DrawDebugGraph(), SCR_DrawNet(), SCR_TileClear(), and V_RenderView().