fte/quakespasm
2
0
Fork 0
mirror of https://github.com/Shpoike/Quakespasm.git synced 2024-11-10 07:21:58 +00:00
Code Issues Projects Releases Packages Wiki Activity

Added lightmap scaling.

Browse source
This commit is contained in:
Spike 2017-12-15 04:01:14 +00:00 committed by Shpoike
parent fe63ebc870
commit afb6583375
6 changed files with 122 additions and 36 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
Quake/bspfile.h
View file

@ -244,6 +244,8 @@ typedef struct
} dledge_t;
#define MAXLIGHTMAPS 4
#define LMBLOCK_WIDTH 256
#define LMBLOCK_HEIGHT 256
typedef struct
{
short planenum;

108
Quake/gl_model.c
View file

@ -37,6 +37,7 @@ qmodel_t *Mod_LoadModel (qmodel_t *mod, qboolean crash);
cvar_t external_ents = {"external_ents", "1", CVAR_ARCHIVE};
cvar_t gl_load24bit = {"gl_load24bit", "1", CVAR_ARCHIVE};
cvar_t mod_ignorelmscale = {"mod_ignorelmscale", "0"};
static byte *mod_novis;
static int mod_novis_capacity;
@ -61,6 +62,7 @@ void Mod_Init (void)
Cvar_RegisterVariable (&gl_subdivide_size);
Cvar_RegisterVariable (&external_ents);
Cvar_RegisterVariable (&gl_load24bit);
Cvar_RegisterVariable (&mod_ignorelmscale);
//johnfitz -- create notexture miptex
r_notexture_mip = (texture_t *) Hunk_AllocName (sizeof(texture_t), "r_notexture_mip");
@ -469,12 +471,13 @@ static char *bspxbase;
static bspx_header_t *bspxheader;
//supported lumps:
//RGBLIGHTING (.lit)
//LMSHIFT (.lit2)
//LMOFFSET (LMSHIFT helper)
//LMSTYLE (LMSHIFT helper)
//unsupported lumps ('documented' elsewhere):
//BRUSHLIST (because hulls suck)
//LIGHTINGDIR (.lux)
//LMSHIFT (.lit2)
//LMOFFSET (.lit2)
//LMSTYLE (.lit2)
static void *Q1BSPX_FindLump(char *lumpname, int *lumpsize)
{
int i;
@ -999,6 +1002,46 @@ _load_embedded:
}
/*
=================
Mod_ParseWorldspawnKey
=================
(Blame Spike)
This just quickly scans the worldspawn entity for a single key. Returning both _prefixed and non prefixed keys.
(wantkey argument should not have a _prefix.)
*/
const char *Mod_ParseWorldspawnKey(qmodel_t *mod, const char *wantkey, char *buffer, size_t sizeofbuffer)
{
char foundkey[128];
const char *data = COM_Parse(mod->entities);
if (data && com_token[0] == '{')
{
while (1)
{
data = COM_Parse(data);
if (!data)
break; // error
if (com_token[0] == '}')
break; // end of worldspawn
if (com_token[0] == '_')
strcpy(foundkey, com_token + 1);
else
strcpy(foundkey, com_token);
data = COM_Parse(data);
if (!data)
break; // error
if (!strcmp(wantkey, foundkey))
{
q_strlcpy(buffer, com_token, sizeofbuffer);
return buffer;
}
}
}
return NULL;
}
/*
=================
Mod_LoadVertexes
@ -1164,6 +1207,7 @@ void CalcSurfaceExtents (msurface_t *s)
mvertex_t *v;
mtexinfo_t *tex;
int bmins[2], bmaxs[2];
int maxextent, lmscale;
mins[0] = mins[1] = FLT_MAX;
maxs[0] = maxs[1] = -FLT_MAX;
@ -1207,15 +1251,18 @@ void CalcSurfaceExtents (msurface_t *s)
}
}
lmscale = 1<<s->lmshift;
maxextent = q_max(LMBLOCK_WIDTH,LMBLOCK_HEIGHT)*lmscale;
for (i=0 ; i<2 ; i++)
{
bmins[i] = floor(mins[i]/16);
bmaxs[i] = ceil(maxs[i]/16);
bmins[i] = floor(mins[i]/lmscale);
bmaxs[i] = ceil(maxs[i]/lmscale);
s->texturemins[i] = bmins[i] * 16;
s->extents[i] = (bmaxs[i] - bmins[i]) * 16;
s->texturemins[i] = bmins[i] * lmscale;
s->extents[i] = (bmaxs[i] - bmins[i]) * lmscale;
if ( !(tex->flags & TEX_SPECIAL) && s->extents[i] > 2000) //johnfitz -- was 512 in glquake, 256 in winquake
if ( !(tex->flags & TEX_SPECIAL) && s->extents[i] > maxextent) //johnfitz -- was 512 in glquake, 256 in winquake
Sys_Error ("Bad surface extents");
}
}
@ -1314,9 +1361,15 @@ void Mod_LoadFaces (lump_t *l, qboolean bsp2)
dsface_t *ins;
dlface_t *inl;
msurface_t *out;
int i, count, surfnum, lofs;
int i, count, surfnum, lofs, shift;
int planenum, side, texinfon;
unsigned char *lmshift = NULL, defaultshift = 4;
unsigned int *lmoffset = NULL;
unsigned char *lmstyle = NULL;
int lumpsize;
char scalebuf[16];
if (bsp2)
{
ins = NULL;
@ -1340,13 +1393,33 @@ void Mod_LoadFaces (lump_t *l, qboolean bsp2)
Con_DWarning ("%i faces exceeds standard limit of 32767.\n", count);
//johnfitz
if (!mod_ignorelmscale.value)
{
lmshift = Q1BSPX_FindLump("LMSHIFT", &lumpsize);
if (lumpsize != sizeof(*lmshift)*count)
lmshift = NULL;
lmoffset = Q1BSPX_FindLump("LMOFFSET", &lumpsize);
if (lumpsize != sizeof(*lmoffset)*count)
lmoffset = NULL;
lmstyle = Q1BSPX_FindLump("LMSTYLE", &lumpsize);
if (lumpsize != sizeof(*lmstyle)*MAXLIGHTMAPS*count)
lmstyle = NULL;
if (Mod_ParseWorldspawnKey(loadmodel, "lightmap_scale", scalebuf, sizeof(scalebuf)))
{
i = atoi(scalebuf);
for (defaultshift = 0; (1<<defaultshift) < i && defaultshift < 254; defaultshift++)
break;
}
}
loadmodel->surfaces = out;
loadmodel->numsurfaces = count;
for (surfnum=0 ; surfnum<count ; surfnum++, out++)
{
if (bsp2)
{
{ //32bit datatypes
out->firstedge = LittleLong(inl->firstedge);
out->numedges = LittleLong(inl->numedges);
planenum = LittleLong(inl->planenum);
@ -1358,7 +1431,7 @@ void Mod_LoadFaces (lump_t *l, qboolean bsp2)
inl++;
}
else
{
{ //16bit datatypes
out->firstedge = LittleLong(ins->firstedge);
out->numedges = LittleShort(ins->numedges);
planenum = LittleShort(ins->planenum);
@ -1369,6 +1442,15 @@ void Mod_LoadFaces (lump_t *l, qboolean bsp2)
lofs = LittleLong(ins->lightofs);
ins++;
}
shift = defaultshift;
//bspx overrides (for lmscale)
if (lmstyle)
shift = lmshift[surfnum];
if (lmoffset)
lofs = LittleLong(lmoffset[surfnum]);
if (lmstyle)
for (i=0 ; i<MAXLIGHTMAPS ; i++)
out->styles[i] = lmstyle[surfnum*MAXLIGHTMAPS+i];
out->flags = 0;
@ -1376,8 +1458,8 @@ void Mod_LoadFaces (lump_t *l, qboolean bsp2)
out->flags |= SURF_PLANEBACK;
out->plane = loadmodel->planes + planenum;
out->texinfo = loadmodel->texinfo + texinfon;
out->lmshift = shift;
CalcSurfaceExtents (out);
@ -2357,13 +2439,13 @@ void Mod_LoadBrushModel (qmodel_t *mod, void *buffer)
Mod_LoadLighting (&header->lumps[LUMP_LIGHTING]);
Mod_LoadPlanes (&header->lumps[LUMP_PLANES]);
Mod_LoadTexinfo (&header->lumps[LUMP_TEXINFO]);
Mod_LoadEntities (&header->lumps[LUMP_ENTITIES]); //Spike: moved this earlier, so that we can parse worldspawn keys earlier.
Mod_LoadFaces (&header->lumps[LUMP_FACES], bsp2);
Mod_LoadMarksurfaces (&header->lumps[LUMP_MARKSURFACES], bsp2);
Mod_LoadVisibility (&header->lumps[LUMP_VISIBILITY]);
Mod_LoadLeafs (&header->lumps[LUMP_LEAFS], bsp2);
Mod_LoadNodes (&header->lumps[LUMP_NODES], bsp2);
Mod_LoadClipnodes (&header->lumps[LUMP_CLIPNODES], bsp2);
Mod_LoadEntities (&header->lumps[LUMP_ENTITIES]);
Mod_LoadSubmodels (&header->lumps[LUMP_MODELS]);
Mod_MakeHull0 ();

1
Quake/gl_model.h
View file

@ -147,6 +147,7 @@ typedef struct msurface_s
short extents[2];
int light_s, light_t; // gl lightmap coordinates
unsigned char lmshift;
glpoly_t *polys; // multiple if warped
struct msurface_s *texturechain;

6
Quake/gl_rlight.c
View file

@ -346,9 +346,9 @@ loc0:
byte *lightmap;
int maps, line3, dsfrac = ds & 15, dtfrac = dt & 15, r00 = 0, g00 = 0, b00 = 0, r01 = 0, g01 = 0, b01 = 0, r10 = 0, g10 = 0, b10 = 0, r11 = 0, g11 = 0, b11 = 0;
float scale;
line3 = ((surf->extents[0]>>4)+1)*3;
line3 = ((surf->extents[0]>>surf->lmshift)+1)*3;
lightmap = surf->samples + ((dt>>4) * ((surf->extents[0]>>4)+1) + (ds>>4))*3; // LordHavoc: *3 for color
lightmap = surf->samples + ((dt>>surf->lmshift) * ((surf->extents[0]>>surf->lmshift)+1) + (ds>>surf->lmshift))*3; // LordHavoc: *3 for color
for (maps = 0;maps < MAXLIGHTMAPS && surf->styles[maps] != 255;maps++)
{
@ -357,7 +357,7 @@ loc0:
r01 += (float) lightmap[ 3] * scale;g01 += (float) lightmap[ 4] * scale;b01 += (float) lightmap[5] * scale;
r10 += (float) lightmap[line3+0] * scale;g10 += (float) lightmap[line3+1] * scale;b10 += (float) lightmap[line3+2] * scale;
r11 += (float) lightmap[line3+3] * scale;g11 += (float) lightmap[line3+4] * scale;b11 += (float) lightmap[line3+5] * scale;
lightmap += ((surf->extents[0]>>4)+1) * ((surf->extents[1]>>4)+1)*3; // LordHavoc: *3 for colored lighting
lightmap += ((surf->extents[0]>>surf->lmshift)+1) * ((surf->extents[1]>>surf->lmshift)+1)*3; // LordHavoc: *3 for colored lighting
}
color[0] += (float) ((int) ((((((((r11-r10) * dsfrac) >> 4) + r10)-((((r01-r00) * dsfrac) >> 4) + r00)) * dtfrac) >> 4) + ((((r01-r00) * dsfrac) >> 4) + r00)));

6
Quake/pr_ext.c
View file

@ -1851,10 +1851,8 @@ static void PF_getsurfacepointattribute(void)
G_FLOAT(OFS_RETURN+2) = 0;
break;
case 5: //lmst coord, not actually very useful
#define BLOCK_WIDTH 128
#define BLOCK_HEIGHT 128
G_FLOAT(OFS_RETURN+0) = (DotProduct(v->position, fa->texinfo->vecs[0]) + fa->texinfo->vecs[0][3] - fa->texturemins[0] + fa->light_s*16+8) / (BLOCK_WIDTH*16);
G_FLOAT(OFS_RETURN+1) = (DotProduct(v->position, fa->texinfo->vecs[1]) + fa->texinfo->vecs[1][3] - fa->texturemins[1] + fa->light_t*16+8) / (BLOCK_HEIGHT*16);
G_FLOAT(OFS_RETURN+0) = (DotProduct(v->position, fa->texinfo->vecs[0]) + fa->texinfo->vecs[0][3] - fa->texturemins[0] + (fa->light_s+.5)*(1<<fa->lmshift)) / (LMBLOCK_WIDTH*(1<<fa->lmshift));
G_FLOAT(OFS_RETURN+1) = (DotProduct(v->position, fa->texinfo->vecs[1]) + fa->texinfo->vecs[1][3] - fa->texturemins[1] + (fa->light_t+.5)*(1<<fa->lmshift)) / (LMBLOCK_HEIGHT*(1<<fa->lmshift));
G_FLOAT(OFS_RETURN+2) = 0;
break;
case 6: //colour

35
Quake/r_brush.c
View file

@ -690,8 +690,8 @@ dynamic:
theRect->w += theRect->l - fa->light_s;
theRect->l = fa->light_s;
}
smax = (fa->extents[0]>>4)+1;
tmax = (fa->extents[1]>>4)+1;
smax = (fa->extents[0]>>fa->lmshift)+1;
tmax = (fa->extents[1]>>fa->lmshift)+1;
if ((theRect->w + theRect->l) < (fa->light_s + smax))
theRect->w = (fa->light_s-theRect->l)+smax;
if ((theRect->h + theRect->t) < (fa->light_t + tmax))
@ -782,8 +782,8 @@ void GL_CreateSurfaceLightmap (qmodel_t *model, msurface_t *surf)
int smax, tmax;
byte *base;
smax = (surf->extents[0]>>4)+1;
tmax = (surf->extents[1]>>4)+1;
smax = (surf->extents[0]>>surf->lmshift)+1;
tmax = (surf->extents[1]>>surf->lmshift)+1;
surf->lightmaptexturenum = AllocBlock (smax, tmax, &surf->light_s, &surf->light_t);
base = lightmap[surf->lightmaptexturenum].data;
@ -803,6 +803,7 @@ void BuildSurfaceDisplayList (msurface_t *fa)
float *vec;
float s, t;
glpoly_t *poly;
int lmscale = (1<<fa->lmshift);
// reconstruct the polygon
pedges = currentmodel->edges;
@ -845,15 +846,15 @@ void BuildSurfaceDisplayList (msurface_t *fa)
//
s = DotProduct (vec, fa->texinfo->vecs[0]) + fa->texinfo->vecs[0][3];
s -= fa->texturemins[0];
s += fa->light_s*16;
s += 8;
s /= LMBLOCK_WIDTH*16; //fa->texinfo->texture->width;
s += fa->light_s*lmscale;
s += lmscale/2.0;
s /= LMBLOCK_WIDTH*lmscale; //fa->texinfo->texture->width;
t = DotProduct (vec, fa->texinfo->vecs[1]) + fa->texinfo->vecs[1][3];
t -= fa->texturemins[1];
t += fa->light_t*16;
t += 8;
t /= LMBLOCK_HEIGHT*16; //fa->texinfo->texture->height;
t += fa->light_t*lmscale;
t += lmscale/2.0;
t /= LMBLOCK_HEIGHT*lmscale; //fa->texinfo->texture->height;
poly->verts[i][5] = s;
poly->verts[i][6] = t;
@ -1056,10 +1057,12 @@ void R_AddDynamicLights (msurface_t *surf)
float cred, cgreen, cblue, brightness;
unsigned *bl;
//johnfitz
int lmscale;
smax = (surf->extents[0]>>4)+1;
tmax = (surf->extents[1]>>4)+1;
smax = (surf->extents[0]>>surf->lmshift)+1;
tmax = (surf->extents[1]>>surf->lmshift)+1;
tex = surf->texinfo;
lmscale = 1<<surf->lmshift;
for (lnum=0 ; lnum<MAX_DLIGHTS ; lnum++)
{
@ -1095,12 +1098,12 @@ void R_AddDynamicLights (msurface_t *surf)
//johnfitz
for (t = 0 ; t<tmax ; t++)
{
td = local[1] - t*16;
td = local[1] - t*lmscale;
if (td < 0)
td = -td;
for (s=0 ; s<smax ; s++)
{
sd = local[0] - s*16;
sd = local[0] - s*lmscale;
if (sd < 0)
sd = -sd;
if (sd > td)
@ -1142,8 +1145,8 @@ void R_BuildLightMap (qmodel_t *model, msurface_t *surf, byte *dest, int stride)
surf->cached_dlight = (surf->dlightframe == r_framecount);
smax = (surf->extents[0]>>4)+1;
tmax = (surf->extents[1]>>4)+1;
smax = (surf->extents[0]>>surf->lmshift)+1;
tmax = (surf->extents[1]>>surf->lmshift)+1;
size = smax*tmax;
lightmap = surf->samples;