/*
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 the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/
// gl_ngraph.c

#include "client.h"
#include "draw.h"
#include "glquake.h"
#include "menu.h"
#include "quakedef.h"
#include "sbar.h"

// FIXME - header hacks
extern byte *draw_chars;

GLuint netgraphtexture;		// netgraph texture

#define NET_GRAPHHEIGHT 32

static byte ngraph_texels[NET_GRAPHHEIGHT][NET_TIMINGS];

static void
R_LineGraph(int x, int h)
{
    int i;
    int s;
    int color;

    s = NET_GRAPHHEIGHT;

    if (h == 10000)
	color = 0x6f;		// yellow
    else if (h == 9999)
	color = 0x4f;		// red
    else if (h == 9998)
	color = 0xd0;		// blue
    else
	color = 0xfe;		// white

    if (h > s)
	h = s;

    for (i = 0; i < h; i++)
	if (i & 1)
	    ngraph_texels[NET_GRAPHHEIGHT - i - 1][x] = 0xff;
	else
	    ngraph_texels[NET_GRAPHHEIGHT - i - 1][x] = (byte)color;

    for (; i < s; i++)
	ngraph_texels[NET_GRAPHHEIGHT - i - 1][x] = (byte)0xff;
}

void
Draw_CharToNetGraph(int x, int y, int num)
{
    int row, col;
    byte *source;
    int drawline;
    int nx;

    row = num >> 4;
    col = num & 15;
    source = draw_chars + (row << 10) + (col << 3);

    for (drawline = 8; drawline; drawline--, y++) {
	for (nx = 0; nx < 8; nx++)
	    if (source[nx] != 255)
		ngraph_texels[y][nx + x] = 0x60 + source[nx];
	source += 128;
    }
}


/*
==============
R_NetGraph
==============
*/
void
R_NetGraph(void)
{
    int a, x, i, y;
    int lost;
    char st[80];
    unsigned ngraph_pixels[NET_GRAPHHEIGHT][NET_TIMINGS];

    x = 0;
    lost = CL_CalcNet();
    for (a = 0; a < NET_TIMINGS; a++) {
	i = (cls.netchan.outgoing_sequence - a) & NET_TIMINGSMASK;
	R_LineGraph(NET_TIMINGS - 1 - a, packet_latency[i]);
    }

    // now load the netgraph texture into gl and draw it
    for (y = 0; y < NET_GRAPHHEIGHT; y++)
	for (x = 0; x < NET_TIMINGS; x++)
	    ngraph_pixels[y][x] = d_8to24table[ngraph_texels[y][x]];

    x = -((vid.width - 320) >> 1);
    y = vid.height - sb_lines - 24 - NET_GRAPHHEIGHT - 1;

    M_DrawTextBox(x, y, NET_TIMINGS / 8, NET_GRAPHHEIGHT / 8 + 1);
    y += 8;

    sprintf(st, "%3i%% packet loss", lost);
    Draw_String(8, y, st);
    y += 8;

    GL_Bind(netgraphtexture);

    glTexImage2D(GL_TEXTURE_2D, 0, gl_alpha_format,
		 NET_TIMINGS, NET_GRAPHHEIGHT, 0, GL_RGBA,
		 GL_UNSIGNED_BYTE, ngraph_pixels);

    glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

    x = 8;
    glColor3f(1, 1, 1);
    glBegin(GL_QUADS);
    glTexCoord2f(0, 0);
    glVertex2f(x, y);
    glTexCoord2f(1, 0);
    glVertex2f(x + NET_TIMINGS, y);
    glTexCoord2f(1, 1);
    glVertex2f(x + NET_TIMINGS, y + NET_GRAPHHEIGHT);
    glTexCoord2f(0, 1);
    glVertex2f(x, y + NET_GRAPHHEIGHT);
    glEnd();
}
