quakeforge-old/common/vid_aa.c

/*
	vid_aa.c

	(description)

	Copyright (C) 1996-1997  Id Software, Inc.
	Copyright (C) 1999-2000  Nelson Rush.
	Copyright (C) 1999,2000  contributors of the QuakeForge project
	Please see the file "AUTHORS" for a list of contributors

	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

	$Id$
*/

#include <quakedef.h>
#include <d_local.h>

#include <stdio.h>
#include <stdlib.h>
#include <aalib.h>

#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif
#if defined(HAVE_SYS_IO_H)
# include <sys/io.h>
#elif defined(HAVE_ASM_IO_H)
# include <asm/io.h>
#endif

static byte	*vid_surfcache;
static int	VID_highhunkmark;

static int		num_modes, current_mode;
static vga_modeinfo	*modes;

static byte	vid_current_palette[768];

static int	UseDisplay = 1;

static cvar_t	*vid_mode;
static cvar_t	*vid_redrawfull;
static cvar_t	*vid_waitforrefresh;

static char	*framebuffer_ptr;

static byte	backingbuf[48*24];

aa_context	*context = NULL;
unsigned char	*buffer;
aa_palette	palette;
aa_renderparams	*params;
int		aaversion=0;

void
aa_setpage ( void )
{
	int		x,y;
	unsigned char	*img = aa_image(context);

	switch(aaversion) {
		case 11:
			for (y = 0; y < 200; y++)
				memcpy(img+y*aa_imgwidth(context),buffer+y*320,320);
			break;
		case 12:
			for (y=0;y<100;y++)
				memcpy(img+y*aa_imgwidth(context),buffer+y*320*2,320);
			break;
		case 13:
			for (y=0;y<66;y++)
				memcpy(img+y*aa_imgwidth(context),buffer+y*320*3,320);
			break;
		case 14:
			for (y=0;y<50;y++)
				memcpy(img+y*aa_imgwidth(context),buffer+y*320*4,320);
			break;
		case 21:
			for (y = 0; y < 200; y++)
				for (x=0;x<160;x++)
					img[y*aa_imgwidth(context)+x]=buffer[y*320+x*2];
			break;
		case 22:
			for (y=0;y<100;y++)
				for (x=0;x<160;x++)
					img[y*aa_imgwidth(context)+x]=buffer[y*2*320+x*2];
			break;
		case 23:
			for (y=0;y<66;y++)
				for (x=0;x<160;x++)
					img[y*aa_imgwidth(context)+x]=buffer[y*3*320+x*2];
			break;
		case 24:
			for (y=0;y<50;y++)
				for (x=0;x<160;x++)
					img[y*aa_imgwidth(context)+x]=buffer[y*4*320+x*2];
			break;
		default:
			fprintf(stderr,"version = %i, unknown version!\n",aaversion);
			exit(-1);
			break;
	}

	aa_renderpalette(context, palette, params, 0, 0,
			aa_scrwidth(context), aa_scrheight(context));
	aa_flush(context);
}

void
D_BeginDirectRect ( int x, int y, byte *pbitmap, int width, int height )
{
	int	i, j, k, plane, reps, repshift, offset, vidpage, off;

	if (vid.aspect > 1.5) {
		reps = 2;
		repshift = 1;
	} else {
		reps = 1;
		repshift = 0;
	}

	vidpage = 0;
	aa_setpage();

	for (i=0 ; i<(height << repshift) ; i += reps) {
		for (j=0 ; j<reps ; j++) {
			offset = x + ((y << repshift) + i + j)
					* vid.rowbytes;
			off = offset % 0x10000;
			if ((offset / 0x10000) != vidpage) {
				vidpage=offset / 0x10000;
				aa_setpage();
			}
			memcpy (&backingbuf[(i + j) * 24],
				vid.direct + off, width);
			memcpy (vid.direct + off,
				&pbitmap[(i >> repshift)*width],
				width);
		}
	}
}


void
D_EndDirectRect ( int x, int y, int width, int height )
{
	int	i, j, k, plane, reps, repshift, offset, vidpage, off;

	if (vid.aspect > 1.5) {
		reps = 2;
		repshift = 1;
	} else {
		reps = 1;
		repshift = 0;
	}

	vidpage = 0;
	aa_setpage();

	for (i=0 ; i<(height << repshift) ; i += reps) {
		for (j=0 ; j<reps ; j++) {
			offset = x + ((y << repshift) + i + j)
					* vid.rowbytes;
			off = offset % 0x10000;
			if ((offset / 0x10000) != vidpage) {
				vidpage=offset / 0x10000;
				aa_setpage();
			}
			memcpy (vid.direct + off,
			&backingbuf[(i +j)*24],	width);
		}
	}
}


#if 0
static void
VID_Gamma_f ( void )
{
	float		gamma, f, inf;
	unsigned char	palette[768];
	int		i;

	if (Cmd_Argc () == 2) {
		gamma = Q_atof (Cmd_Argv(1));

		for (i=0 ; i<768 ; i++)	{
			f = pow ( (host_basepal[i]+1)/256.0 , gamma );
			inf = f*255 + 0.5;
			if (inf < 0) inf = 0;
			if (inf > 255) inf = 255;
			palette[i] = inf;
		}

		VID_SetPalette (palette);

		/* Force a surface cache flush */
		vid.recalc_refdef = 1;
	}
}
#endif


static void
VID_DescribeMode_f ( void )
{
}


static void
VID_DescribeModes_f ( void )
{
}


/*
================
VID_NumModes
================
*/
static int
VID_NumModes ( void )
{
	return 1;
}


static void
VID_NumModes_f ( void )
{
	Con_Printf("%i modes\n", VID_NumModes());
}


static void
VID_Debug_f ( void )
{
/*
	Con_Printf("mode: %i\n",current_mode);
	Con_Printf("height x width: %i x %i\n",vid.height,vid.width);
	Con_Printf("bpp: %i\n",modes[current_mode].bytesperpixel*8);
	Con_Printf("vid.aspect: %f\n",vid.aspect);
*/
}


void
VID_Shutdown ( void )
{
	aa_close(context);
	free(buffer);
}


void
VID_ShiftPalette ( unsigned char *p )
{
	VID_SetPalette(p);
}


void
VID_SetPalette ( byte *palette )
{
	static int	tmppal[256*3];
	int		*tp;
	int		i;

	memcpy(vid_current_palette, palette, sizeof(vid_current_palette));

	tp = tmppal;
	for (i=256*3 ; i ; i--) {
		*(tp++) = *(palette++) >> 2;
	}

	if (UseDisplay) {
		vga_setpalvec(0, 256, tmppal);
	}

}


int
VID_SetMode ( int modenum, unsigned char *palette )
{
	int	bsize, zsize, tsize;
	int	err;

	vid.aspect = ((float)vid.height / (float)vid.width) * (320.0 / 240.0);
	vid.colormap = (pixel_t *) host_colormap;
	vid.fullbright = 256 - LittleLong (*((int *)vid.colormap + 2048));
	vid.conrowbytes = vid.rowbytes;
	vid.conwidth = vid.width;
	vid.conheight = vid.height;
	vid.numpages = 1;

	vid.maxwarpwidth = WARP_WIDTH;
	vid.maxwarpheight = WARP_HEIGHT;

	/* alloc zbuffer and surface cache */
	if (d_pzbuffer) {
		D_FlushCaches();
		Hunk_FreeToHighMark (VID_highhunkmark);
		d_pzbuffer = NULL;
		vid_surfcache = NULL;
	}

	bsize = vid.rowbytes * vid.height;
	tsize = D_SurfaceCacheForRes (vid.width, vid.height);
	zsize = vid.width * vid.height * sizeof(*d_pzbuffer);

	VID_highhunkmark = Hunk_HighMark ();

	d_pzbuffer = Hunk_HighAllocName (bsize+tsize+zsize, "video");

	vid_surfcache = ((byte *)d_pzbuffer) + zsize;

	vid.conbuffer = vid.buffer = (pixel_t *)(((byte *)d_pzbuffer) + zsize + tsize);

	D_InitCaches (vid_surfcache, tsize);

	if (!context)
		if (context = aa_autoinit(&aa_defparams)) {
			if (buffer = malloc(64000)) {
				params = aa_getrenderparams();
				params->bright = 100;
				params->contrast = 100;
				memset(aa_image(context), 0,
				aa_imgwidth(context) * aa_imgheight(context));
				fprintf(stderr,"%i,%i\n",
					aa_imgwidth(context),
					aa_imgheight(context));
				if (aa_imgwidth(context)>=320)
					aaversion=10;
				else
					aaversion=20;
				if (aa_imgheight(context)>=200)
					aaversion+=1;
				else if (aa_imgheight(context)>=100)
					aaversion+=2;
				else if (aa_imgheight(context)>=66)
					aaversion+=3;
				else
					aaversion+=4
			} else
				exit((perror("malloc"),-1));
		} else {
			fprintf(stderr, "set video failed!\n", x);
			exit(-1);
		}

	VID_SetPalette(palette);

	aa_setpage();

	/* Force a surface cache flush */
	vid.recalc_refdef = 1;

	return 1;
}


void
VID_Init ( unsigned char *palette )
{
	int	w, h, d;
	int	err;

#if 0
	Cmd_AddCommand ("gamma", VID_Gamma_f);
#endif

	if (UseDisplay) {
		vid_mode = Cvar_Get ("vid_mode","5",0,"None");
		vid_redrawfull = Cvar_Get ("vid_redrawfull","0",0,"None");
		vid_waitforrefresh = Cvar_Get ("vid_waitforrefresh","0",
						CVAR_ARCHIVE,"None");

		Cmd_AddCommand("vid_nummodes", VID_NumModes_f);
		Cmd_AddCommand("vid_describemode", VID_DescribeMode_f);
		Cmd_AddCommand("vid_describemodes", VID_DescribeModes_f);
		Cmd_AddCommand("vid_debug", VID_Debug_f);

		/* Interpret command-line params */
		w = h = d = 0;
		if (getenv("GSVGAMODE")) {
			current_mode = get_mode(getenv("AAMODE"), w, h, d);
		} else if (COM_CheckParm("-mode")) {
			current_mode = get_mode(com_argv[COM_CheckParm("-mode")+1], w, h, d);
		} else if (COM_CheckParm("-w") || COM_CheckParm("-h")
			|| COM_CheckParm("-d")) {
			if (COM_CheckParm("-w")) {
				w = Q_atoi(com_argv[COM_CheckParm("-w")+1]);
			}
			if (COM_CheckParm("-h")) {
				h = Q_atoi(com_argv[COM_CheckParm("-h")+1]);
			}
			if (COM_CheckParm("-d")) {
				d = Q_atoi(com_argv[COM_CheckParm("-d")+1]);
			}
			current_mode = get_mode(0, w, h, d);
		} else {
			current_mode = 5;
		}

		/* Set vid parameters */
		VID_SetMode(current_mode, palette);

		VID_SetPalette(palette);
	}
}


void
VID_Update ( vrect_t *rects )
{
	int	ycount;
	int	offset;
	int	vidpage=0;

	vga_setpage();

	while (rects) {
		ycount = rects->height;
		offset = rects->y * vid.rowbytes + rects->x;
		while (ycount--) {
			register int	i = offset % 0x10000;

			if ((offset / 0x10000) != vidpage) {
				vidpage=offset / 0x10000;
				aa_setpage();
			}
			if (rects->width + i > 0x10000) {
				memcpy(framebuffer_ptr + i,
					vid.buffer + offset,
					0x10000 - i);
				aa_setpage();
				memcpy(framebuffer_ptr,
					vid.buffer + offset + 0x10000 - i,
					rects->width - 0x10000 + i);
			} else {
				memcpy(framebuffer_ptr + i,
					vid.buffer + offset,
					rects->width);
			}
			offset += vid.rowbytes;
		}
		rects = rects->pnext;
	}

	if (vid_mode->value != current_mode) {
		VID_SetMode ((int)vid_mode->value, vid_current_palette);
	}
}


static int	dither = 0;

void
VID_DitherOn ( void )
{
	if (dither == 0) {
#if 0
		R_ViewChanged (&vrect, sb_lines, vid.aspect);
#endif
		dither = 1;
	}
}


void
VID_DitherOff ( void )
{
	if (dither) {
#if 0
		R_ViewChanged (&vrect, sb_lines, vid.aspect);
#endif
		dither = 0;
	}
}


/*
================
VID_ModeInfo
================
*/
char *
VID_ModeInfo ( int modenum )
{
/*
	static char	*badmodestr = "Bad mode number";
	static char	modestr[40];

	if (modenum == 0) {
		snprintf(modestr, sizeof(modestr), "%i x %i, %i bpp",
			 vid.width, vid.height, modes[current_mode].bytesperpixel*8);
		return (modestr);
	} else {
		return (badmodestr);
	}
*/
}

int
VID_ExtraOptionDraw ( unsigned int options_draw_cursor )
{
	int	drawn;

	drawn = 0;

/* Port specific Options menu entries */
#if 0
	M_Print (16, options_draw_cursor+=8, "                 Dummy");
	M_DrawCheckbox (220, options_draw_cursor, dummy->value);
	drawn++;
#endif

	return drawn;	// return number of drawn menu entries
}

void
VID_ExtraOptionCmd ( int option_cursor, int dir )
{
/* dir: -1 = LEFT, 0 = ENTER, 1 = RIGHT */
#if 0
	switch(option_cursor) {
	case 0:	// Always start with 0
		dummy->value = !dummy->value;
		break;
	}
#endif
}

void
VID_InitCvars ( void )
{
	// It may not look like it, but this is important
}

void
VID_LockBuffer ( void )
{
}

void
VID_UnlockBuffer ( void )
{
}