r_main.c

/* r_main.c */

#include "doomdef.h"
#include "r_local.h"
#ifdef MARS
#include "mars.h"
#include "marshw.h"
#endif

int16_t viewportWidth, viewportHeight;
int16_t centerX, centerY;
fixed_t centerXFrac, centerYFrac;
fixed_t stretch;
fixed_t stretchX;
VINT weaponYpos;
fixed_t weaponXScale;
boolean lowres = false;

VINT detailmode;

VINT anamorphicview = 0;
VINT initmathtables = 2;

drawcol_t drawcol;
drawcol_t drawfuzzcol;
drawcol_t drawcolnpo2;
drawspan_t drawspan[2];
drawcol_t draw4bcol;
drawcol_t draw4bcolnpo2;

short fuzzoffset[FUZZTABLE] =
{
	1,-1,1,-1,1,1,-1,
	1,1,-1,1,1,1,-1,
	1,1,1,-1,-1,-1,-1,
	1,-1,-1,1,1,1,1,-1,
	1,-1,1,1,-1,-1,1,
	1,-1,-1,-1,-1,1,1,
	1,1,-1,1,1,-1,1,
	-1,-1,1,-1,1,1,1,
	1,-1,1,-1,-1,1,1
};

/*===================================== */

#ifndef MARS
boolean		phase1completed;

pixel_t		*workingscreen;
#endif

#ifdef MARS
static int16_t	curpalette = -1;

__attribute__((aligned(16)))
pixel_t* viewportbuffer;

__attribute__((aligned(16)))
#endif
viewdef_t       *vd;

VINT			framecount;		/* incremented every frame */

VINT		extralight;			/* bumped light from gun blasts */

/* */
/* precalculated math */
/* */
#ifndef MARS
fixed_t	*finecosine_ = &finesine_[FINEANGLES/4];
#endif

fixed_t *yslope/*[SCREENHEIGHT]*/;
uint16_t *distscale/*[SCREENWIDTH]*/;

VINT *viewangletox/*[FINEANGLES/2]*/;

uint16_t *xtoviewangle/*[SCREENWIDTH+1]*/;

/* */
/* performance counters */
/* */
VINT t_ref_cnt = 0;
int t_ref_bsp[4], t_ref_prep[4], t_ref_segs[4], t_ref_planes[4], t_ref_sprites[4], t_ref_total[4];

r_texcache_t r_texcache;

/*
===============================================================================
=
= R_PointToAngle
=
===============================================================================
*/

static int SlopeAngle (unsigned int num, unsigned int den) ATTR_DATA_CACHE_ALIGN;

static int SlopeAngle (unsigned num, unsigned den)
{
	unsigned ans;
	angle_t *t2a;

	den >>= 8;
#ifdef MARS
	SH2_DIVU_DVSR = den;
	SH2_DIVU_DVDNT = num << 3;

    __asm volatile (
      "mov.l %1, %0"
      : "=r" (t2a)
      : "m" (tantoangle)
   );

   if (den < 2)
	  ans = SLOPERANGE;
   else
      ans = SH2_DIVU_DVDNT;
#else
	if (den < 2)
		ans = SLOPERANGE;
	else
		ans = (num<<3)/den;
	t2a = tantoangle;
#endif
	ans = ans <= SLOPERANGE ? ans : SLOPERANGE;
	return t2a[ans];
}

angle_t R_PointToAngle (fixed_t x1, fixed_t y1, fixed_t x2, fixed_t y2)
{	
	int		x;
	int		y;
	int 	base = 0;
	int 	num = 0, den = 0, n = 1;
	
	x = x2 - x1;
	y = y2 - y1;
	
	if ( (!x) && (!y) )
		return 0;
	if (x>= 0)
	{	/* x >=0 */
		if (y>= 0)
		{	/* y>= 0 */
			if (x>y)
			{
				/* octant 0 */
				num = y, den = x;
			}
			else
			{
				/* octant 1 */
				base = ANG90-1, n = -1,	num = x, den = y;
			}
		}
		else
		{	/* y<0 */
			y = -y;
			if (x>y)
			{
				n = -1, num = y, den = x; /* octant 8 */
			}
			else
			{
				base = ANG270, n = 1, num = x, den = y; /* octant 7 */
			}
		}
	}
	else
	{	/* x<0 */
		x = -x;
		if (y>= 0)
		{	/* y>= 0 */
			if (x>y)
			{
				base = ANG180-1, n = -1, num = y, den = x; /* octant 3 */
			}
			else
			{
				base = ANG90, num = x, den = y; /* octant 2 */
			}
		}
		else
		{	/* y<0 */
			y = -y;
			if (x>y)
			{
				base = ANG180, num = y, den = x; /* octant 4 */
			}
			else
			{
				base = ANG270-1, n = -1, num = x, den = y; /* octant 5 */
			}
		}
	}
	return base + n * SlopeAngle(num, den);
}

/*
==============
=
= R_PointInSubsector
=
==============
*/

struct subsector_s *R_PointInSubsector2 (fixed_t x, fixed_t y, int nodenum)
{
	node_t	*node;
	int		side;
	
	if (!numnodes)				/* single subsector is a special case */
		return subsectors;

#ifdef MARS
	while ( (int16_t)nodenum >= 0 )
#else
	while (! (nodenum & NF_SUBSECTOR) )
#endif
	{
		node = &nodes[nodenum];
		side = R_PointOnSide(x, y, node);
		nodenum = node->children[side];
	}
	
	return &subsectors[nodenum & ~NF_SUBSECTOR];
	
}

/*============================================================================= */

const VINT viewports[][2][3] = {
	{ { 160, 90, false }, { 160, 100, false } },
	{ { 224, 128, false }, { 160, 100, false } },
	{ { 256, 144, false }, { 160, 128, false } },
	{ { 320, 180, true }, { 160, 144, true } },
};

VINT viewportNum;
const VINT numViewports = sizeof(viewports) / sizeof(viewports[0]);

/*
================
=
= R_SetViewportSize
=
================
*/
void R_SetViewportSize(int num)
{
	int width, height;

	while (!I_RefreshCompleted())
		;

	num %= numViewports;

	width = viewports[num][splitscreen ? 1 : 0][0];
	height = viewports[num][splitscreen ? 1 : 0][1];
	if (lowres)
		width /= 2;

	viewportNum = num;
	viewportWidth = width;
	viewportHeight = height;

	centerX = viewportWidth / 2;
	centerY = viewportHeight / 2;

	centerXFrac = centerX * FRACUNIT;
	centerYFrac = centerY * FRACUNIT;

	if (anamorphicview)
	{
		stretch = ((FRACUNIT * 16 * height) / 180 * 28) / width;
	}
	else
	{
		/* proper screen size would be 160*100, stretched to 224 is 2.2 scale */
		//stretch = (fixed_t)((160.0f / width) * ((float)height / 180.0f) * 2.2f * FRACUNIT);
		stretch = ((FRACUNIT * 16 * height) / 180 * 22) / width;
	}
	weaponXScale = FRACUNIT / (lowres ? 2 : 1);
	stretchX = stretch * centerX;

	weaponYpos = 180;
	if (viewportHeight < 128) {
		weaponYpos = 120;
	} else if (viewportHeight == 128) {
		weaponYpos = 144;
	} else if (viewportHeight <= 144) {
		weaponYpos = 162;
	}
	weaponYpos = (viewportHeight - weaponYpos) / 2;

	initmathtables = 2;
	clearscreen = 2;

	// refresh func pointers
	R_SetDrawFuncs();

#ifdef MARS
	Mars_CommSlaveClearCache();
#endif
}

void R_SetDrawFuncs(void)
{
	if (debugmode == DEBUGMODE_NODRAW)
	{
		drawcol = I_DrawColumnNoDraw;
		drawcolnpo2 = I_DrawColumnNoDraw;
		drawfuzzcol = I_DrawColumnNoDraw;
		drawspan[0] = drawspan[1] = I_DrawSpanNoDraw;
		draw4bcol = I_DrawColumnNoDraw;
		draw4bcolnpo2 = I_DrawColumnNoDraw;
		return;
	}

	if (detailmode < detmode_potato || detailmode >= MAXDETAILMODES)
		detailmode = DETAILMODE_DEFAULT;

	if (lowres)
	{
		drawcol = I_DrawColumnLow;
		draw4bcol = I_Draw4bColumnLow;
		drawcolnpo2 = I_DrawColumnNPo2Low;
		draw4bcolnpo2 = I_Draw4bColumnNPo2Low;
		drawfuzzcol = I_DrawFuzzColumnLow;
		switch (detailmode) {
			case detmode_potato:
				drawspan[0] = I_DrawSpanPotatoLow;
				drawspan[1] = I_DrawSpanPotatoLow;
				break;
			default:
				drawspan[0] = I_DrawSpanLow;
				drawspan[1] = I_DrawSpanLowSwap;
				break;
		}
	}
	else
	{
		drawcol = I_DrawColumn;
		draw4bcol = I_Draw4bColumn;
		drawcolnpo2 = I_DrawColumnNPo2;
		draw4bcolnpo2 = I_Draw4bColumnNPo2;
		drawfuzzcol = I_DrawFuzzColumn;
		switch (detailmode) {
			case detmode_potato:
				drawspan[0] = I_DrawSpanPotatoLow;	
				drawspan[1] = I_DrawSpanPotatoLow;
				break;
			case detmode_lowres:
				drawspan[0] = I_DrawSpanLow;
				drawspan[1] = I_DrawSpanLowSwap;
				break;
			default:
				drawspan[0] = I_DrawSpan;
				drawspan[1] = I_DrawSpan;
				break;
		}
	}

#ifdef MARS
	Mars_ClearCache();
	Mars_CommSlaveClearCache();
#endif
}

int R_DefaultViewportSize(void)
{
	int i;

	for (i = 0; i < numViewports; i++)
	{
		const VINT* vp = viewports[i][0];
		if (vp[2] == true)
			return i;
	}

	return 0;
}

/*
==============
=
= R_Init
=
==============
*/

void R_Init (void)
{
D_printf ("R_InitData\n");
	R_InitData ();
D_printf ("Done\n");

	R_InitTexCache(&r_texcache);

	R_SetViewportSize(viewportNum);

	R_EnableLowResMode(lowres);

	framecount = 0;

	R_SetDrawFuncs();
}

/*
==============
=
= R_SetTextureData
=
==============
*/
void R_SetTextureData(texture_t *tex, uint8_t *start, int size, boolean skipheader)
{
	int j;
	int mipcount = 1;
	int w = tex->width, h = tex->height;
	jagobj_t *header;
	uint8_t *data = skipheader ? R_SkipJagObjHeader(start, size, w, h, &header) : start;
	uint8_t *end = start + size;
#if MIPLEVELS > 1
	boolean masked = tex->lumpnum >= firstsprite && tex->lumpnum < firstsprite + numsprites;

	if (texmips && !masked)
		mipcount = tex->mipcount;
#endif
	int bpp = header ?  BIGSHORT(header->depth) : 3;
	int flags = header ? BIGSHORT(header->flags) : 0;

	tex->colormaps = NULL;
	if ((bpp == 2) && (flags & 0x8) != 0) {
		tex->colormaps = (int8_t *)end - 33*16*2;
	}

	for (j = 0; j < mipcount; j++)
	{
		int size;
		if (bpp == 2)
			size = w * ((h + 1) & ~1) / 2;
		else
			size = w * h;

		tex->data[j] = data;
		if (!data) {
			continue;
		}

#if MIPLEVELS > 1
		if (j && data+size > end) {
			// no mipmaps
			tex->mipcount = 1;
			break;
		}
#endif

		data += size;

		w >>= 1;
		if (w < 1)
			w = 1;

		h >>= 1;
		if (h < 1)
			h = 1;
	}
}

/*
==============
=
= R_SetFlatData
=
==============
*/
void R_SetFlatData(int f, uint8_t *start, int size)
{
	int j;
	int w = 64;
	uint8_t *data = start;

	for (j = 0; j < MIPLEVELS; j++)
	{
		flatpixels[f].data[j] = data;
		if (!data) {
			continue;
		}
		if (texmips) {
			data += w * w;
			w >>= 1;
		}
	}
}

void R_ClearTextures(void)
{
	int i;

	// reset pointers from previous level
	for (i = 0; i < numtextures; i++)
		R_SetTextureData(&textures[i], NULL, 0, 0);
	for (i=0 ; i<numflats ; i++)
		R_SetFlatData(i, NULL, 0);
}

void R_FixupTextures(void)
{
	int i;

	// reset pointers from previous level
	for (i = 0; i < numtextures; i++)
	{
		int length;
		boolean skipheader;
		uint8_t *data;
		int lump = textures[i].lumpnum;

		if (textures[i].data[0]) {
			continue;
		}

		if (lump >= firstsprite && lump < firstsprite + numsprites) {
			length = W_LumpLength(lump+1);
			data = W_POINTLUMPNUM(lump+1);
			skipheader = false;
		} else if (W_IsCompressed(lump)) {
			length = W_LumpLength(lump);
			data = Z_Malloc (length,PU_LEVEL);
			W_ReadLump(lump, data);
			skipheader = true;
		} else {
			length = W_LumpLength(lump);
			data = R_CheckPixels(lump);
			skipheader = true;
		}

		R_SetTextureData(&textures[i], data, length, skipheader);
	}

	for (i=0 ; i<numflats ; i++)
	{
		int length;
		uint8_t *data;
		int lump = firstflat + i;

		if (flatpixels[i].data[0]) {
			continue;
		}

		data = R_CheckPixels(lump);
		length = W_LumpLength(lump);
		if (W_IsCompressed(lump)) {
			data = Z_Malloc (length, PU_LEVEL);
			W_ReadLump(lump, data);
		}

		R_SetFlatData(i, data, length);
	}
}

/*
==============
=
= R_SetupTextureCaches
=
==============
*/
void R_SetupTextureCaches(int gamezonemargin)
{
	int zonefree;
	int cachezonesize;
	void *margin;
	const int zonemargin = gamezonemargin;
	const int flatblocksize = sizeof(memblock_t) + ((sizeof(texcacheblock_t) + 15) & ~15) + 64*64 + 32;

	// functioning texture cache requires at least 8kb of ram
	zonefree = Z_LargestFreeBlock(mainzone);
	if (zonefree < zonemargin+flatblocksize)
		goto nocache;

	cachezonesize = zonefree - zonemargin - 128; // give the main zone some slack
	if (cachezonesize < flatblocksize)
		goto nocache;
	
	margin = Z_Malloc(zonemargin, PU_LEVEL);

	R_InitTexCacheZone(&r_texcache, cachezonesize);

	Z_Free(margin);
	return;

nocache:
	R_InitTexCacheZone(&r_texcache, 0);
}

void R_SetupLevel(int gamezonemargin)
{
	R_SetupTextureCaches(gamezonemargin);

	R_SetViewportSize(viewportNum);

	R_EnableLowResMode(lowres);

#ifdef MARS
	curpalette = -1;
#endif
}

static void R_ColorShiftPalette(const uint8_t *in, int idx, uint8_t *out) __attribute__((noinline));

static void R_ColorShiftPalette(const uint8_t *in, int idx, uint8_t *out)
{
	int	i;
	const uint8_t *pin;
	uint8_t *pout;
	int r, g, b, shift, steps;
	static const uint8_t palette_shifts[][5] = {
		{ 255, 0, 0, 1, 9 }, // 1
		{ 255, 0, 0, 2, 9 }, // 2
		{ 255, 0, 0, 3, 9 }, // 3
		{ 255, 0, 0, 4, 9 }, // 4
		{ 255, 0, 0, 5, 9 }, // 5
		{ 255, 0, 0, 6, 9 }, // 6
		{ 255, 0, 0, 7, 9 }, // 7
		{ 255, 0, 0, 8, 9 }, // 8
		{ 215, 186, 69, 1, 8 }, // 9
		{ 215, 186, 69, 2, 8 }, // 10
		{ 215, 186, 69, 3, 8 }, // 11
		{ 215, 186, 69, 4, 8 }, // 12
		{ 0, 255, 0, 1, 8 }, // 13
		{ 0, 0, 255, 1, 8 }, // 14
	};

	if (idx == 0 || idx > (int)(sizeof(palette_shifts)/sizeof(palette_shifts[0]))) {
		return;
	}

	--idx;

	r = palette_shifts[idx][0];
	g = palette_shifts[idx][1];
	b = palette_shifts[idx][2];
	shift = palette_shifts[idx][3];
	steps = palette_shifts[idx][4];

	pin = in;
	pout = out;

	for (i = 0; i < 256; i++)
	{
		int nr = pin[0] + (((r - pin[0])*shift)/steps);
		int ng = pin[1] + (((g - pin[1])*shift)/steps);
		int nb = pin[2] + (((b - pin[2])*shift)/steps);

		if (nr < 0) nr = 0;
		if (nr > 255) nr = 255;

		if (ng < 0) ng = 0;
		if (ng > 255) ng = 255;

		if (nb < 0) nb = 0;
		if (nb > 255) nb = 255;

		pout[0] = nr;
		pout[1] = ng;
		pout[2] = nb;

		pin += 3;
		pout += 3;
	}
}

/*============================================================================= */

#ifndef MARS
int shadepixel;
extern	int	workpage;
extern	pixel_t	*screens[2];	/* [viewportWidth*viewportHeight];  */
#endif

/*
==================
=
= R_Setup
=
==================
*/

static void R_Setup (int displayplayer, sector_t **vissectors_)
{
	int 		i;
	int		damagecount, bonuscount;
	player_t *player;
#ifdef JAGUAR
	int		shadex, shadey, shadei;
#endif
	unsigned short  *tempbuf;
#ifdef MARS
	int		palette = 0;
#endif

/* */
/* set up globals for new frame */
/* */
#ifndef MARS
	workingscreen = screens[workpage];

	*(pixel_t  **)0xf02224 = workingscreen;	/* a2 base pointer */
	*(int *)0xf02234 = 0x10000;				/* a2 outer loop add (+1 y) */
	*(int *)0xf0226c = *(int *)0xf02268 = 0;		/* pattern compare */
#else
	if (debugmode == DEBUGMODE_NODRAW)
		I_ClearFrameBuffer();
#endif

	I_SetBankPage(segspage);

	framecount++;	
	validcount[0]++;

	player = &players[displayplayer];

	vd->psprites = player->psprites;
	vd->viewx = player->mo->x;
	vd->viewy = player->mo->y;
	vd->viewz = player->viewz;
	vd->viewangle = player->mo->angle;

	vd->viewsin = finesine(vd->viewangle>>ANGLETOFINESHIFT);
	vd->viewcos = finecosine(vd->viewangle>>ANGLETOFINESHIFT);

	vd->displayplayer = displayplayer;
	vd->lightlevel = SSEC_SECTOR(player->mo->subsector)->lightlevel;
	vd->fixedcolormap = 0;

	vd->clipangle = xtoviewangle[0]<<FRACBITS;
	vd->viewangletox = viewangletox;

	damagecount = player->damagecount;
	bonuscount = player->bonuscount;

#ifdef JAGUAR
	vd->extralight = player->extralight << 6;

/* */
/* calc shadepixel */
/* */
	if (damagecount)
		damagecount += 10;
	if (bonuscount)
		bonuscount += 2;
	damagecount >>= 2;
	shadex = (bonuscount>>1) + damagecount;
	shadey = (bonuscount>>1) - damagecount;
	shadei = (bonuscount + damagecount)<<2;

	shadei += player->extralight<<3;

/* */
/* pwerups */
/* */
	if (player->powers[pw_invulnerability] > 60
	|| (player->powers[pw_invulnerability]&4) )
	{
		shadex -= 8;
		shadei += 32;
	}

	if (player->powers[pw_ironfeet] > 60
	|| (player->powers[pw_ironfeet]&4) )
		shadey += 7;

	if (player->powers[pw_strength] 
	&& (player->powers[pw_strength]< 64) )
		shadex += (8 - (player->powers[pw_strength]>>3) );


/* */
/* bound and store shades */
/* */
	if (shadex > 7)
		shadex = 7;
	else if (shadex < -8)
		shadex = -8;
	if (shadey > 7)
		shadey = 7;
	else if (shadey < -8)
		shadey = -8;
	if (shadei > 127)
		shadei = 127;
	else if (shadei < -128)
		shadei = -128;
		
	shadepixel = ((shadex<<12)&0xf000) + ((shadey<<8)&0xf00) + (shadei&0xff);
#endif

#ifdef MARS
	vd->extralight = player->extralight << 4;

	if (player->powers[pw_invulnerability] > 0)
	{
		if (player->powers[pw_invulnerability] > 60
			|| (player->powers[pw_invulnerability] & 4))
			vd->fixedcolormap = INVERSECOLORMAP;
	}
    else if (player->powers[pw_infrared] > 0)
    {
		if (player->powers[pw_infrared] > 4*32
			|| (player->powers[pw_infrared] & 4) )
		{
			// almost full bright
			vd->fixedcolormap = 1*256;
		}
	}

	if (player->powers[pw_invisibility] > 4*32
		|| player->powers[pw_invisibility] & 4)
	{
		vd->shadow = true;
	}
	else
	{
		vd->shadow = false;
	}

	viewportbuffer = (pixel_t*)I_ViewportBuffer();

	palette = 0;

	i = 0;
	if (player->powers[pw_strength] > 0)
		i = 12 - player->powers[pw_strength] / 64;
	if (i < damagecount)
		i = damagecount;

	if (gamepaused)
		palette = 14;
	else if (!splitscreen)
	{
		if (i)
		{
			palette = (i + 7) / 8;
			if (palette > 7)
				palette = 7;
			palette += 1;
		}
		else if (bonuscount)
		{
			palette = (bonuscount + 7) / 8;
			if (palette > 3)
				palette = 3;
			palette += 9;
		}
		else if (player->powers[pw_ironfeet] > 60
			|| (player->powers[pw_ironfeet] & 4))
			palette = 13;
	}
	
	if (palette != curpalette) {
		curpalette = palette;

		if (palette == 0) {
			I_SetPalette(dc_playpals);
		} else {
			R_ColorShiftPalette(dc_playpals, palette, dc_cshift_playpals);
			I_SetPalette(dc_cshift_playpals);
		}
	}

	if (vd->fixedcolormap == INVERSECOLORMAP)
		vd->fuzzcolormap = INVERSECOLORMAP;
	else
		vd->fuzzcolormap = 12 * 256;
#endif

	tempbuf = (unsigned short *)I_WorkBuffer();

	vd->visplanes = (void*)tempbuf;
	vd->visplanes[0].flatandlight = 0;
	tempbuf += sizeof(*vd->visplanes) * MAXVISPLANES / sizeof(*tempbuf);

/* */
/* plane filling */
/*	 */
	tempbuf = (unsigned short*)(((intptr_t)tempbuf + 3) & ~3);
	tempbuf += 2; // padding
	for (i = 0; i < MAXVISPLANES; i++) {
		vd->visplanes[i].open = tempbuf;
		tempbuf += SCREENWIDTH+2;
	}

	vd->segclip = tempbuf;
	tempbuf += MAXOPENINGS;

	tempbuf = (unsigned short*)(((intptr_t)tempbuf + 3) & ~3);
	vd->viswalls = (void*)tempbuf;
	tempbuf += sizeof(*vd->viswalls) * MAXWALLCMDS / sizeof(*tempbuf);

	vd->sortedvisplanes = (void *)tempbuf;
	vd->gsortedvisplanes = NULL;

	vd->gsortedsprites = (void *)tempbuf;
	tempbuf += sizeof(*vd->gsortedsprites) * (MAXVISSPRITES+1) / sizeof(*tempbuf);

	vd->vissprites = (void *)vd->viswalls;

	vd->lastwallcmd = vd->viswalls;			/* no walls added yet */
	vd->lastsegclip = vd->segclip;

	vd->lastvisplane = vd->visplanes + 1;		/* visplanes[0] is left empty */
	vd->visplanes_hash = NULL;

	tempbuf = (unsigned short*)(((intptr_t)tempbuf + 3) & ~3);
	vd->columncache[0] = (uint8_t*)tempbuf;
	tempbuf += sizeof(uint8_t) * COLUMN_CACHE_SIZE * 2 / sizeof(*tempbuf);

	tempbuf = (unsigned short*)(((intptr_t)tempbuf + 3) & ~3);
	vd->columncache[1] = (uint8_t*)tempbuf;
	tempbuf += sizeof(uint8_t) * COLUMN_CACHE_SIZE * 2 / sizeof(*tempbuf);

	//I_Error("%d", ((uint16_t *)I_FrameBuffer() + 64*1024-0x100 - tempbuf) * 2);

	I_SetThreadLocalVar(DOOMTLS_COLUMNCACHE, vd->columncache[0]);

	/* */
	/* clear sprites */
	/* */
	vd->vissprite_p = vd->vissprites;
	vd->lastsprite_p = vd->vissprite_p;

	vd->vissectors = vissectors_;
	vd->lastvissector = vd->vissectors;	/* no subsectors visible yet */

#ifndef MARS
	phasetime[0] = samplecount;
#endif
}

#ifdef MARS

void Mars_Sec_R_Setup(void)
{
	Mars_ClearCacheLines(&vd, 1);
	Mars_ClearCacheLines(vd, (sizeof(*vd) + 31) / 16);
	Mars_ClearCacheLine(&viewportbuffer);

	//Mars_ClearCacheLines(vd->visplanes, (sizeof(visplane_t)*MAXVISPLANES+31)/16);

	I_SetThreadLocalVar(DOOMTLS_COLUMNCACHE, vd->columncache[1]);
}

#endif

//
// Check for a matching visplane in the visplanes array, or set up a new one
// if no compatible match can be found.
//
#define R_PlaneHash(height, lightlevel) \
	((((unsigned)(height) >> 8) + (flatandlight>>16)) ^ (flatandlight&0xffff)) & (NUM_VISPLANES_BUCKETS - 1)

void R_MarkOpenPlane(visplane_t* pl)
{
	unsigned longs = (unsigned)(viewportWidth + 1) / 2;
	uint32_t * open = (uint32_t *)pl->open;
	const uint32_t v = ((uint32_t)OPENMARK << 16) | OPENMARK;
	unsigned longlongs = longs / 2;

	do {
		*open++ = v;
		*open++ = v;
	} while (--longlongs > 0);
}

void R_InitClipBounds(uint32_t *clipbounds)
{
	// initialize the clipbounds array
	int i;
	int longs = (viewportWidth + 1) / 2;
	uint32_t* clip = clipbounds;
	const uint32_t v = ((uint32_t)viewportHeight << 16) | viewportHeight;
	for (i = 0; i < longs/2; i++)
	{
		*clip++ = v;
		*clip++ = v;
	}
}

visplane_t* R_FindPlane(fixed_t height, 
	int flatandlight, int start, int stop)
{
	visplane_t *check, *tail, *next;
	int hash = R_PlaneHash(height, flatandlight);

	tail = vd->visplanes_hash[hash];
	for (check = tail; check; check = next)
	{
		next = check->next;

		if (height == check->height && // same plane as before?
			flatandlight == check->flatandlight)
		{
			if (MARKEDOPEN(check->open[start]))
			{
				// found a plane, so adjust bounds and return it
				if (start < check->minx)
					check->minx = start; // mark the new edge
				if (stop > check->maxx)
					check->maxx = stop;  // mark the new edge
				return check; // use the same one as before
			}
		}
	}

	if (vd->lastvisplane == vd->visplanes + MAXVISPLANES)
		return vd->visplanes;

	// make a new plane
	check = vd->lastvisplane;
	++vd->lastvisplane;

	check->height = height;
	check->flatandlight = flatandlight;
	check->minx = start;
	check->maxx = stop;

	R_MarkOpenPlane(check);

	check->next = tail;
	vd->visplanes_hash[hash] = check;

	return check;
}

void R_BSP (void) __attribute__((noinline));
void R_WallPrep (void) __attribute__((noinline));
void R_SpritePrep (void) __attribute__((noinline));
boolean R_LatePrep (void) __attribute__((noinline));
void R_Cache (void) __attribute__((noinline));
void R_SegCommands (void) __attribute__((noinline));
void R_DrawPlanes (void) __attribute__((noinline));
void R_Sprites (void) __attribute__((noinline));
void R_Update (void) __attribute__((noinline));

/*
==============
=
= R_RenderView
=
==============
*/

extern	boolean	debugscreenactive;

#ifndef MARS
int		phasetime[9] = {1,2,3,4,5,6,7,8,9};

extern	ref1_start;
extern	ref2_start;
extern	ref3_start;
extern	ref4_start;
extern	ref5_start;
extern	ref6_start;
extern	ref7_start;
extern	ref8_start;

void R_RenderPlayerView(int displayplayer)
{
	sector_t *vissectors_[MAXVISSSEC];

	/* make sure its done now */
#if defined(JAGUAR)
	while (!I_RefreshCompleted())
		;
#endif

	/* */
	/* initial setup */
	/* */
	if (debugscreenactive)
		I_DebugScreen();

	R_Setup(displayplayer, vissectors_);

#ifndef JAGUAR
	R_BSP();

	R_WallPrep();
	/* the rest of the refresh can be run in parallel with the next game tic */
	if (R_LatePrep())
		R_Cache();

	R_SegCommands();

	R_DrawPlanes();

	R_SpritePrep();

	R_Sprites();

	R_Update();
#else

	/* start the gpu running the refresh */
	phasetime[1] = 0;
	phasetime[2] = 0;
	phasetime[3] = 0;
	phasetime[4] = 0;
	phasetime[5] = 0;
	phasetime[6] = 0;
	phasetime[7] = 0;
	phasetime[8] = 0;
	gpufinished = zero;
	gpucodestart = (int)&ref1_start;

#endif
}

#else

void R_RenderPlayerView(int displayplayer)
{
	int t_bsp, t_prep, t_segs, t_planes, t_sprites, t_total;
	boolean drawworld = !(players[consoleplayer].automapflags & AF_ACTIVE);
	sector_t *vissectors_[MAXVISSSEC];

	t_total = I_GetFRTCounter();

	R_Setup(displayplayer, vissectors_);

	Mars_R_BeginWallPrep(drawworld);

	t_bsp = I_GetFRTCounter();
	R_BSP();
	t_bsp = I_GetFRTCounter() - t_bsp;

	Mars_R_EndWallPrep();

	if (!drawworld)
	{
		Mars_R_SecWait();
		return;
	}

	t_prep = I_GetFRTCounter();
	R_Cache();
	t_prep = I_GetFRTCounter() - t_prep;

	t_segs = I_GetFRTCounter();
	R_SegCommands();
	t_segs = I_GetFRTCounter() - t_segs;

	Mars_ClearCacheLine(&vd->lastsegclip);

	if (vd->lastsegclip - vd->segclip > MAXOPENINGS)
		I_Error("lastsegclip > MAXOPENINGS: %d", vd->lastsegclip - vd->segclip);
	if (vd->lastvissector - vd->vissectors > MAXVISSSEC)
		I_Error("lastvissector > MAXVISSSEC: %d", vd->lastvissector - vd->vissectors);

	t_planes = I_GetFRTCounter();
	R_DrawPlanes();
	t_planes = I_GetFRTCounter() - t_planes;

	t_sprites = I_GetFRTCounter();
	R_SpritePrep();
	R_Sprites();
	t_sprites = I_GetFRTCounter() - t_sprites;
	
	R_Update();

	t_total = I_GetFRTCounter() - t_total;

	t_ref_cnt = (t_ref_cnt + 1) & 3;
	t_ref_bsp[t_ref_cnt] = t_bsp;
	t_ref_prep[t_ref_cnt] = t_prep;
	t_ref_segs[t_ref_cnt] = t_segs;
	t_ref_planes[t_ref_cnt] = t_planes;
	t_ref_sprites[t_ref_cnt] = t_sprites;
	t_ref_total[t_ref_cnt] = t_total;
}

#endif