summaryrefslogtreecommitdiff
path: root/source/sw_surf.c
diff options
context:
space:
mode:
Diffstat (limited to 'source/sw_surf.c')
-rw-r--r--source/sw_surf.c438
1 files changed, 438 insertions, 0 deletions
diff --git a/source/sw_surf.c b/source/sw_surf.c
new file mode 100644
index 0000000..f8633bc
--- /dev/null
+++ b/source/sw_surf.c
@@ -0,0 +1,438 @@
+/*
+Copyright (C) 1997-2001 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.
+
+*/
+// r_surf.c: surface-related refresh code
+
+#include "sw_local.h"
+
+drawsurf_t r_drawsurf;
+
+int lightleft, sourcesstep, blocksize, sourcetstep;
+int lightdelta, lightdeltastep;
+int lightright, lightleftstep, lightrightstep, blockdivshift;
+unsigned blockdivmask;
+void *prowdestbase;
+unsigned char *pbasesource;
+int surfrowbytes; // used by ASM files
+unsigned *r_lightptr;
+int r_stepback;
+int r_lightwidth;
+int r_numhblocks, r_numvblocks;
+unsigned char *r_source, *r_sourcemax;
+
+void R_DrawSurfaceBlock8_mip0 (void);
+void R_DrawSurfaceBlock8_mip1 (void);
+void R_DrawSurfaceBlock8_mip2 (void);
+void R_DrawSurfaceBlock8_mip3 (void);
+
+static void (*surfmiptable[4])(void) = {
+ R_DrawSurfaceBlock8_mip0,
+ R_DrawSurfaceBlock8_mip1,
+ R_DrawSurfaceBlock8_mip2,
+ R_DrawSurfaceBlock8_mip3
+};
+
+void R_BuildLightMap (void);
+extern blocklight_t blocklights[MAX_BLOCKLIGHTS]; // allow some very large lightmaps
+
+float surfscale;
+qboolean r_cache_thrash; // set if surface cache is thrashing
+
+int sc_size;
+surfcache_t *sc_rover, *sc_base;
+
+/*
+===============
+R_TextureAnimation
+
+Returns the proper texture for a given time and base texture
+===============
+*/
+image_t *R_TextureAnimation (mtexinfo_t *tex)
+{
+ int c;
+
+ if (!tex->next)
+ return tex->image;
+
+ c = currententity->frame % tex->numframes;
+ while (c)
+ {
+ tex = tex->next;
+ c--;
+ }
+
+ return tex->image;
+}
+
+/*
+===============
+R_DrawSurface
+===============
+*/
+void R_DrawSurface( void ) {
+ byte *basetptr;
+ int smax, tmax, twidth;
+ int u;
+ int soffset, toffset;
+ int horzblockstep;
+ byte *pcolumndest;
+ void (*pblockdrawer)(void);
+ image_t *mt;
+
+ surfrowbytes = r_drawsurf.rowbytes;
+
+ mt = r_drawsurf.image;
+
+ r_source = mt->pixels[r_drawsurf.surfmip];
+
+// the fractional light values should range from 0 to (VID_GRADES - 1) << 16
+// from a source range of 0 - 255
+
+ /* width in bytes */
+ twidth = ( mt->upload_width >> r_drawsurf.surfmip ) * VID_BYTES;
+
+ blocksize = 16 >> r_drawsurf.surfmip;
+ blockdivshift = 4 - r_drawsurf.surfmip;
+ blockdivmask = (1 << blockdivshift) - 1;
+
+ r_lightwidth = ((r_drawsurf.surf->extents[0]>>4)+1)*LIGHTMAP_BYTES;
+
+ r_numhblocks = r_drawsurf.surfwidth >> blockdivshift;
+ r_numvblocks = r_drawsurf.surfheight >> blockdivshift;
+
+//==============================
+
+ pblockdrawer = surfmiptable[r_drawsurf.surfmip];
+// TODO: only needs to be set when there is a display settings change
+ horzblockstep = blocksize << VID_SHIFT;
+
+ smax = mt->upload_width >> r_drawsurf.surfmip;
+ tmax = mt->upload_height >> r_drawsurf.surfmip;
+ sourcetstep = twidth;
+ r_stepback = tmax * twidth;
+
+ r_sourcemax = r_source + ( tmax * smax * VID_BYTES );
+
+ soffset = r_drawsurf.surf->texturemins[0];
+ toffset = r_drawsurf.surf->texturemins[1];
+
+// << 16 components are to guarantee positive values for %
+ soffset = ((soffset >> r_drawsurf.surfmip) + (smax << 16)) % smax;
+ toffset = ((toffset >> r_drawsurf.surfmip) + (tmax << 16)) % tmax;
+
+ basetptr = &r_source[toffset * twidth];
+
+ pcolumndest = r_drawsurf.surfdat;
+
+ for( u = 0; u < r_numhblocks; u++ ) {
+ r_lightptr = ( unsigned * )blocklights + u * LIGHTMAP_BYTES;
+
+ prowdestbase = pcolumndest;
+
+ pbasesource = basetptr + ( soffset << VID_SHIFT );
+
+ (*pblockdrawer)();
+
+ soffset += blocksize;
+ if( soffset >= smax )
+ soffset = 0;
+
+ pcolumndest += horzblockstep;
+ }
+}
+
+//=============================================================================
+#if !USE_ASM
+
+#define BLOCK_FUNC R_DrawSurfaceBlock8_mip0
+#define BLOCK_SHIFT 4
+#include "sw_block.h"
+
+#define BLOCK_FUNC R_DrawSurfaceBlock8_mip1
+#define BLOCK_SHIFT 3
+#include "sw_block.h"
+
+#define BLOCK_FUNC R_DrawSurfaceBlock8_mip2
+#define BLOCK_SHIFT 2
+#include "sw_block.h"
+
+#define BLOCK_FUNC R_DrawSurfaceBlock8_mip3
+#define BLOCK_SHIFT 1
+#include "sw_block.h"
+
+#endif
+
+
+//============================================================================
+
+
+/*
+================
+R_InitCaches
+
+================
+*/
+void R_InitCaches (void)
+{
+ int size;
+ int pix;
+
+ // calculate size to allocate
+ if (sw_surfcacheoverride->integer)
+ {
+ size = sw_surfcacheoverride->integer;
+ }
+ else
+ {
+ size = SURFCACHE_SIZE_AT_320X240;
+
+ pix = vid.width*vid.height;
+ if (pix > 64000)
+ size += (pix-64000)*3;
+ }
+
+ // round up to page size
+ size = (size + 8191) & ~8191;
+
+ Com_Printf("%ik surface cache\n", size/1024);
+
+ sc_size = size;
+ sc_base = (surfcache_t *)R_Malloc(size);
+ sc_rover = sc_base;
+
+ sc_base->next = NULL;
+ sc_base->owner = NULL;
+ sc_base->size = sc_size;
+}
+
+
+/*
+==================
+D_FlushCaches
+==================
+*/
+void D_FlushCaches (void)
+{
+ surfcache_t *c;
+
+ if (!sc_base)
+ return;
+
+ for (c = sc_base ; c ; c = c->next)
+ {
+ if (c->owner){
+ *c->owner = NULL;
+ }
+ }
+
+ sc_rover = sc_base;
+ sc_base->next = NULL;
+ sc_base->owner = NULL;
+ sc_base->size = sc_size;
+}
+
+/*
+=================
+D_SCAlloc
+=================
+*/
+surfcache_t *D_SCAlloc (int width, int size)
+{
+ surfcache_t *new;
+ qboolean wrapped_this_time;
+
+ if ((width < 0) || (width > 256))
+ Com_Error (ERR_FATAL,"D_SCAlloc: bad cache width %d\n", width);
+
+ if ((size <= 0) || (size > 0x10000))
+ Com_Error (ERR_FATAL,"D_SCAlloc: bad cache size %d\n", size);
+
+ size = (int)&((surfcache_t *)0)->data[size];
+ size = (size + 3) & ~3;
+ if (size > sc_size)
+ Com_Error (ERR_FATAL,"D_SCAlloc: %i > cache size of %i",size, sc_size);
+
+// if there is not size bytes after the rover, reset to the start
+ wrapped_this_time = qfalse;
+
+ if ( !sc_rover || (byte *)sc_rover - (byte *)sc_base > sc_size - size)
+ {
+ if (sc_rover)
+ {
+ wrapped_this_time = qtrue;
+ }
+ sc_rover = sc_base;
+ }
+
+// colect and free surfcache_t blocks until the rover block is large enough
+ new = sc_rover;
+ if (sc_rover->owner)
+ *sc_rover->owner = NULL;
+
+ while (new->size < size)
+ {
+ // free another
+ sc_rover = sc_rover->next;
+ if (!sc_rover)
+ Com_Error (ERR_FATAL,"D_SCAlloc: hit the end of memory");
+ if (sc_rover->owner)
+ *sc_rover->owner = NULL;
+
+ new->size += sc_rover->size;
+ new->next = sc_rover->next;
+ }
+
+// create a fragment out of any leftovers
+ if (new->size - size > 256)
+ {
+ sc_rover = (surfcache_t *)( (byte *)new + size);
+ sc_rover->size = new->size - size;
+ sc_rover->next = new->next;
+ sc_rover->width = 0;
+ sc_rover->owner = NULL;
+ new->next = sc_rover;
+ new->size = size;
+ }
+ else
+ sc_rover = new->next;
+
+ new->width = width;
+// DEBUG
+ if (width > 0)
+ new->height = (size - sizeof(*new) + sizeof(new->data)) / width;
+
+ new->owner = NULL; // should be set properly after return
+
+ if (d_roverwrapped)
+ {
+ if (wrapped_this_time || (sc_rover >= d_initial_rover))
+ r_cache_thrash = qtrue;
+ }
+ else if (wrapped_this_time)
+ {
+ d_roverwrapped = qtrue;
+ }
+
+ return new;
+}
+
+
+/*
+=================
+D_SCDump
+=================
+*/
+void D_SCDump_f (void)
+{
+ surfcache_t *test;
+
+ for (test = sc_base ; test ; test = test->next)
+ {
+ if (test == sc_rover)
+ Com_Printf("ROVER:\n");
+ Com_Printf("%p : %i bytes %i width\n", test, test->size,
+ test->width);
+ }
+}
+
+//=============================================================================
+
+/*
+================
+D_CacheSurface
+================
+*/
+surfcache_t *D_CacheSurface (msurface_t *surface, int miplevel)
+{
+ surfcache_t *cache;
+
+//
+// if the surface is animating or flashing, flush the cache
+//
+ r_drawsurf.image = R_TextureAnimation (surface->texinfo);
+ r_drawsurf.lightadj[0] = r_newrefdef.lightstyles[surface->styles[0]].white*256;
+ r_drawsurf.lightadj[1] = r_newrefdef.lightstyles[surface->styles[1]].white*256;
+ r_drawsurf.lightadj[2] = r_newrefdef.lightstyles[surface->styles[2]].white*256;
+ r_drawsurf.lightadj[3] = r_newrefdef.lightstyles[surface->styles[3]].white*256;
+
+//
+// see if the cache holds apropriate data
+//
+ cache = surface->cachespots[miplevel];
+
+ if (cache && !cache->dlight && surface->dlightframe != r_framecount
+ && cache->image == r_drawsurf.image
+ && cache->lightadj[0] == r_drawsurf.lightadj[0]
+ && cache->lightadj[1] == r_drawsurf.lightadj[1]
+ && cache->lightadj[2] == r_drawsurf.lightadj[2]
+ && cache->lightadj[3] == r_drawsurf.lightadj[3] )
+ return cache;
+
+//
+// determine shape of surface
+//
+ surfscale = 1.0 / (1<<miplevel);
+ r_drawsurf.surfmip = miplevel;
+ r_drawsurf.surfwidth = surface->extents[0] >> miplevel;
+ r_drawsurf.rowbytes = r_drawsurf.surfwidth;
+ 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 (r_drawsurf.surfwidth,
+ r_drawsurf.surfwidth * 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;
+
+ r_drawsurf.surfdat = (pixel_t *)cache->data;
+
+ cache->image = r_drawsurf.image;
+ cache->lightadj[0] = r_drawsurf.lightadj[0];
+ cache->lightadj[1] = r_drawsurf.lightadj[1];
+ cache->lightadj[2] = r_drawsurf.lightadj[2];
+ cache->lightadj[3] = r_drawsurf.lightadj[3];
+
+//
+// draw and light the surface texture
+//
+ r_drawsurf.surf = surface;
+
+ c_surf++;
+
+ // calculate the lightings
+ R_BuildLightMap ();
+
+ // rasterize the surface into the cache
+ R_DrawSurface ();
+
+ return cache;
+}
+
+
generated by cgit v1.2.3 (git 2.46.0) at 2025-08-28 06:18:26 +0000