quakeforge/libs/video/renderer/sw32/d_surf.c

/*
	d_surf.c

	rasterization driver surface heap manager

	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

#define NH_DEFINE
#include "namehack.h"

#include <stdlib.h>

#include "QF/qargs.h"
#include "QF/render.h"
#include "QF/sys.h"

#include "compat.h"
#include "d_local.h"
#include "r_internal.h"
#include "vid_sw.h"

static float        surfscale;

static int          sc_size;
surfcache_t *sw32_sc_rover;
static surfcache_t *sc_base;

#define GUARDSIZE       4


void *
sw32_D_SurfaceCacheAddress (void)
{
	return sc_base;
}


int
sw32_D_SurfaceCacheForRes (void *data, int width, int height)
{
	int         size, pix;

	if (COM_CheckParm ("-surfcachesize")) {
		size = atoi (com_argv[COM_CheckParm ("-surfcachesize") + 1]) * 1024;
		return size;
	}

	size = SURFCACHE_SIZE_AT_320X200;

	pix = width * height;
	if (pix > 64000)
		size += (pix - 64000) * 3;

	size *= sw32_ctx->pixbytes;

	return size;
}


static void
D_CheckCacheGuard (void)
{
	byte       *s;
	int         i;

	s = (byte *) sc_base + sc_size;
	for (i = 0; i < GUARDSIZE; i++)
		if (s[i] != (byte) i)
			Sys_Error ("D_CheckCacheGuard: failed");
}


static void
D_ClearCacheGuard (void)
{
	byte       *s;
	int         i;

	s = (byte *) sc_base + sc_size;
	for (i = 0; i < GUARDSIZE; i++)
		s[i] = (byte) i;
}


void
sw32_D_InitCaches (void *data, void *buffer, int size)
{
	Sys_MaskPrintf (SYS_dev, "D_InitCaches: %ik surface cache\n", size/1024);

	sc_size = size - GUARDSIZE;
	sc_base = (surfcache_t *) buffer;
	sw32_sc_rover = sc_base;

	sc_base->next = NULL;
	sc_base->owner = NULL;
	sc_base->size = sc_size;

	sw32_d_pzbuffer = vid.zbuffer;

	D_ClearCacheGuard ();
}


void
sw32_D_FlushCaches (void *data)
{
	surfcache_t *c;

	if (!sc_base)
		return;

	for (c = sc_base; c; c = c->next) {
		if (c->owner)
			*c->owner = NULL;
	}

	sw32_sc_rover = sc_base;
	sc_base->next = NULL;
	sc_base->owner = NULL;
	sc_base->size = sc_size;
}


static surfcache_t *
D_SCAlloc (int width, int size)
{
	surfcache_t *new;
	qboolean    wrapped_this_time;

	if ((width < 0) || (width > 512))	// FIXME shouldn't really have a max
		Sys_Error ("D_SCAlloc: bad cache width %d", width);

	if ((size <= 0) || (size > (0x40000 * sw32_ctx->pixbytes))) //FIXME ditto
		Sys_Error ("D_SCAlloc: bad cache size %d", size);

	/* This adds the offset of data[0] in the surfcache_t struct. */
	size += field_offset (surfcache_t, data);

#define SIZE_ALIGN	(sizeof(surfcache_t*)-1)
	size = (size + SIZE_ALIGN) & ~SIZE_ALIGN;
#undef SIZE_ALIGN
	size = (size + 3) & ~3;
	if (size > sc_size)
		Sys_Error ("D_SCAlloc: %i > cache size", size);

	// if there is not size bytes after the rover, reset to the start
	wrapped_this_time = false;

	if (!sw32_sc_rover || (byte *) sw32_sc_rover - (byte *) sc_base > sc_size - size) {
		if (sw32_sc_rover) {
			wrapped_this_time = true;
		}
		sw32_sc_rover = sc_base;
	}
	// colect and free surfcache_t blocks until the rover block is large enough
	new = sw32_sc_rover;
	if (sw32_sc_rover->owner)
		*sw32_sc_rover->owner = NULL;

	while (new->size < size) {
		// free another
		sw32_sc_rover = sw32_sc_rover->next;
		if (!sw32_sc_rover)
			Sys_Error ("D_SCAlloc: hit the end of memory");
		if (sw32_sc_rover->owner)
			*sw32_sc_rover->owner = NULL;

		new->size += sw32_sc_rover->size;
		new->next = sw32_sc_rover->next;
	}

	// create a fragment out of any leftovers
	if (new->size - size > 256) {
		sw32_sc_rover = (surfcache_t *) ((byte *) new + size);
		sw32_sc_rover->size = new->size - size;
		sw32_sc_rover->next = new->next;
		sw32_sc_rover->width = 0;
		sw32_sc_rover->owner = NULL;
		new->next = sw32_sc_rover;
		new->size = size;
	} else
		sw32_sc_rover = new->next;

	new->width = width;
// DEBUG
	if (width > 0)
		new->height = (size - sizeof (*new) + sizeof (new->data)) /
			(width * sw32_ctx->pixbytes);

	new->owner = NULL;					// should be set properly after return

	if (sw32_d_roverwrapped) {
		if (wrapped_this_time || (sw32_sc_rover >= sw32_d_initial_rover))
			r_cache_thrash = true;
	} else if (wrapped_this_time) {
		sw32_d_roverwrapped = true;
	}

	D_CheckCacheGuard ();				// DEBUG
	return new;
}


surfcache_t *
sw32_D_CacheSurface (msurface_t *surface, int miplevel)
{
	surfcache_t *cache;

	// if the surface is animating or flashing, flush the cache
	sw32_r_drawsurf.texture = R_TextureAnimation (surface);
	sw32_r_drawsurf.lightadj[0] = d_lightstylevalue[surface->styles[0]];
	sw32_r_drawsurf.lightadj[1] = d_lightstylevalue[surface->styles[1]];
	sw32_r_drawsurf.lightadj[2] = d_lightstylevalue[surface->styles[2]];
	sw32_r_drawsurf.lightadj[3] = d_lightstylevalue[surface->styles[3]];

	// see if the cache holds apropriate data
	cache = surface->cachespots[miplevel];

	if (cache && !cache->dlight && surface->dlightframe != r_framecount
		&& cache->texture == sw32_r_drawsurf.texture
		&& cache->lightadj[0] == sw32_r_drawsurf.lightadj[0]
		&& cache->lightadj[1] == sw32_r_drawsurf.lightadj[1]
		&& cache->lightadj[2] == sw32_r_drawsurf.lightadj[2]
		&& cache->lightadj[3] == sw32_r_drawsurf.lightadj[3])
		return cache;

	// determine shape of surface
	surfscale = 1.0 / (1 << miplevel);
	sw32_r_drawsurf.surfmip = miplevel;
	sw32_r_drawsurf.surfwidth = surface->extents[0] >> miplevel;
	sw32_r_drawsurf.rowbytes = sw32_r_drawsurf.surfwidth * sw32_ctx->pixbytes;
	sw32_r_drawsurf.surfheight = surface->extents[1] >> miplevel;

	// allocate memory if needed
	if (!cache) {
		// if a texture just animated, don't reallocate it
		cache = D_SCAlloc (sw32_r_drawsurf.surfwidth,
						   sw32_r_drawsurf.rowbytes * sw32_r_drawsurf.surfheight);
		surface->cachespots[miplevel] = cache;
		cache->owner = &surface->cachespots[miplevel];
		cache->mipscale = surfscale;
	}

	if (surface->dlightframe == r_framecount)
		cache->dlight = 1;
	else
		cache->dlight = 0;

	sw32_r_drawsurf.surfdat = (byte *) cache->data;

	cache->texture = sw32_r_drawsurf.texture;
	cache->lightadj[0] = sw32_r_drawsurf.lightadj[0];
	cache->lightadj[1] = sw32_r_drawsurf.lightadj[1];
	cache->lightadj[2] = sw32_r_drawsurf.lightadj[2];
	cache->lightadj[3] = sw32_r_drawsurf.lightadj[3];

	// draw and light the surface texture
	sw32_r_drawsurf.surf = surface;

	sw32_c_surf++;
	sw32_R_DrawSurface ();

	return surface->cachespots[miplevel];
}