#include "quakedef.h"
-byte mod_novis[(MAX_MAP_LEAFS + 7)/ 8];
+qbyte mod_novis[(MAX_MAP_LEAFS + 7)/ 8];
cvar_t r_subdivide_size = {CVAR_SAVE, "r_subdivide_size", "128"};
cvar_t halflifebsp = {0, "halflifebsp", "0"};
cvar_t r_novis = {0, "r_novis", "0"};
cvar_t r_miplightmaps = {CVAR_SAVE, "r_miplightmaps", "0"};
cvar_t r_lightmaprgba = {0, "r_lightmaprgba", "1"};
-cvar_t r_vertexsurfacesthreshold = {CVAR_SAVE, "r_vertexsurfacesthreshold", "48"};
+cvar_t r_vertexsurfacesthreshold = {CVAR_SAVE, "r_vertexsurfacesthreshold", "0"};
/*
===============
Mod_DecompressVis
===================
*/
-static byte *Mod_DecompressVis (byte *in, model_t *model)
+static qbyte *Mod_DecompressVis (qbyte *in, model_t *model)
{
- static byte decompressed[MAX_MAP_LEAFS/8];
- int c;
- byte *out;
- int row;
+ static qbyte decompressed[MAX_MAP_LEAFS/8];
+ int c;
+ qbyte *out;
+ int row;
row = (model->numleafs+7)>>3;
out = decompressed;
return decompressed;
}
-byte *Mod_LeafPVS (mleaf_t *leaf, model_t *model)
+qbyte *Mod_LeafPVS (mleaf_t *leaf, model_t *model)
{
if (r_novis.integer || leaf == model->leafs || leaf->compressed_vis == NULL)
return mod_novis;
void Mod_SetupNoTexture(void)
{
- int x, y;
- byte pix[16][16][4];
+ int x, y;
+ qbyte pix[16][16][4];
for (y = 0;y < 16;y++)
{
miptex_t *dmiptex;
texture_t *tx, *tx2, *anims[10], *altanims[10];
dmiptexlump_t *m;
- byte *data, *mtdata, *data2;
+ qbyte *data, *mtdata, *data2;
char name[256];
Mod_SetupNoTexture();
dofs[i] = LittleLong(dofs[i]);
if (dofs[i] == -1)
continue;
- dmiptex = (miptex_t *)((byte *)m + dofs[i]);
+ dmiptex = (miptex_t *)((qbyte *)m + dofs[i]);
mtwidth = LittleLong (dmiptex->width);
mtheight = LittleLong (dmiptex->height);
mtdata = NULL;
// texture included
if (j < 40 || j + mtwidth * mtheight > l->filelen)
Host_Error ("Texture %s is corrupt or incomplete\n", dmiptex->name);
- mtdata = (byte *)dmiptex + j;
+ mtdata = (qbyte *)dmiptex + j;
}
if ((mtwidth & 15) || (mtheight & 15))
}
if (fullbrights)
{
- data2 = Mem_Alloc(tempmempool, tx->width*tx->height);
+ data2 = Mem_Alloc(loadmodel->mempool, tx->width*tx->height);
for (j = 0;j < tx->width*tx->height;j++)
data2[j] = data[j] >= 224 ? 0 : data[j]; // no fullbrights
tx->texture = R_LoadTexture (loadmodel->texturepool, tx->name, tx->width, tx->height, data2, TEXTYPE_QPALETTE, TEXF_MIPMAP | TEXF_PRECACHE);
static void Mod_LoadLighting (lump_t *l)
{
int i;
- byte *in, *out, *data;
- byte d;
+ qbyte *in, *out, *data, d;
char litfilename[1024];
loadmodel->lightdata = NULL;
if (loadmodel->ishlbsp) // LordHavoc: load the colored lighting data straight
strcpy(litfilename, loadmodel->name);
COM_StripExtension(litfilename, litfilename);
strcat(litfilename, ".lit");
- data = (byte*) COM_LoadFile (litfilename, false);
+ data = (qbyte*) COM_LoadFile (litfilename, false);
if (data)
{
if (loadsize > 8 && data[0] == 'Q' && data[1] == 'L' && data[2] == 'I' && data[3] == 'T')
s->texturemins[i] = bmins[i] * 16;
s->extents[i] = (bmaxs[i] - bmins[i]) * 16;
-// if ( !(tex->flags & TEX_SPECIAL) && s->extents[i] > 512)
- if ((tex->flags & TEX_SPECIAL) == 0 && (s->extents[i]+1) > (256*16))
- Host_Error ("Bad surface extents");
}
}
if (r_miplightmaps.integer)
{
surf->lightmaptexturestride = (surf->extents[0]>>4)+1;
- surf->lightmaptexture = R_ProceduralTexture(loadmodel->texturepool, NULL, surf->lightmaptexturestride, (surf->extents[1]>>4)+1, loadmodel->lightmaprgba ? TEXTYPE_RGBA : TEXTYPE_RGB, TEXF_MIPMAP/* | TEXF_PRECACHE*/, NULL, NULL, 0);
+ surf->lightmaptexture = R_ProceduralTexture(loadmodel->texturepool, NULL, surf->lightmaptexturestride, (surf->extents[1]>>4)+1, loadmodel->lightmaprgba ? TEXTYPE_RGBA : TEXTYPE_RGB, TEXF_MIPMAP | TEXF_PRECACHE, NULL, NULL, 0);
}
else
{
surf->lightmaptexturestride = R_CompatibleFragmentWidth((surf->extents[0]>>4)+1, loadmodel->lightmaprgba ? TEXTYPE_RGBA : TEXTYPE_RGB, 0);
- surf->lightmaptexture = R_ProceduralTexture(loadmodel->texturepool, NULL, surf->lightmaptexturestride, (surf->extents[1]>>4)+1, loadmodel->lightmaprgba ? TEXTYPE_RGBA : TEXTYPE_RGB, TEXF_FRAGMENT/* | TEXF_PRECACHE*/, NULL, NULL, 0);
+ surf->lightmaptexture = R_ProceduralTexture(loadmodel->texturepool, NULL, surf->lightmaptexturestride, (surf->extents[1]>>4)+1, loadmodel->lightmaprgba ? TEXTYPE_RGBA : TEXTYPE_RGB, TEXF_FRAGMENT | TEXF_PRECACHE, NULL, NULL, 0);
}
// surf->lightmaptexture = R_LoadTexture(loadmodel->texturepool, va("lightmap%08x", lightmapnum), surf->lightmaptexturestride, (surf->extents[1]>>4)+1, NULL, loadmodel->lightmaprgba ? TEXTYPE_RGBA : TEXTYPE_RGB, TEXF_FRAGMENT | TEXF_PRECACHE);
// surf->lightmaptexture = R_LoadTexture(loadmodel->texturepool, va("lightmap%08x", lightmapnum), surf->lightmaptexturestride, (surf->extents[1]>>4)+1, NULL, loadmodel->lightmaprgba ? TEXTYPE_RGBA : TEXTYPE_RGB, TEXF_PRECACHE);
- R_GetFragmentLocation(surf->lightmaptexture, NULL, NULL, &xbase, &ybase, &xscale, &yscale);
+ R_FragmentLocation(surf->lightmaptexture, NULL, NULL, &xbase, &ybase, &xscale, &yscale);
xscale = (xscale - xbase) * 16.0 / ((surf->extents[0] & ~15) + 16);
yscale = (yscale - ybase) * 16.0 / ((surf->extents[1] & ~15) + 16);
}
}
+void Mod_GenerateVertexMesh (msurface_t *surf)
+{
+ int i, *index;
+ float *in;
+ surfvertex_t *out;
+ surfmesh_t *mesh;
+
+ surf->lightmaptexturestride = 0;
+ surf->lightmaptexture = NULL;
+
+ mesh = &surf->mesh;
+ mesh->numverts = surf->poly_numverts;
+ mesh->numtriangles = surf->poly_numverts - 2;
+ mesh->index = Mem_Alloc(loadmodel->mempool, mesh->numtriangles * sizeof(int[3]) + mesh->numverts * sizeof(surfvertex_t));
+ mesh->vertex = (surfvertex_t *)((long) mesh->index + mesh->numtriangles * sizeof(int[3]));
+ memset(mesh->vertex, 0, mesh->numverts * sizeof(surfvertex_t));
+
+ index = mesh->index;
+ for (i = 0;i < mesh->numtriangles;i++)
+ {
+ *index++ = 0;
+ *index++ = i + 1;
+ *index++ = i + 2;
+ }
+
+ for (i = 0, in = surf->poly_verts, out = mesh->vertex;i < mesh->numverts;i++, in += 3, out++)
+ {
+ VectorCopy (in, out->v);
+ out->st[0] = (DotProduct (out->v, surf->texinfo->vecs[0]) + surf->texinfo->vecs[0][3]) / surf->texinfo->texture->width;
+ out->st[1] = (DotProduct (out->v, surf->texinfo->vecs[1]) + surf->texinfo->vecs[1][3]) / surf->texinfo->texture->height;
+ }
+}
+
void Mod_GenerateSurfacePolygon (msurface_t *surf)
{
float *vert;
{
dface_t *in;
msurface_t *out;
- int i, count, surfnum;
- int planenum, side;
+ int i, count, surfnum, planenum, side, ssize, tsize;
in = (void *)(mod_base + l->fileofs);
if (l->filelen % sizeof(*in))
out->cached_dlight = true;
out->cached_ambient = -1000;
out->cached_lightscalebit = -1000;
- out->cached_light[0] = -1000;
- out->cached_light[1] = -1000;
- out->cached_light[2] = -1000;
- out->cached_light[3] = -1000;
CalcSurfaceExtents (out);
+ ssize = (out->extents[0] >> 4) + 1;
+ tsize = (out->extents[1] >> 4) + 1;
+
// lighting info
for (i = 0;i < MAXLIGHTMAPS;i++)
out->styles[i] = in->styles[i];
if (out->texinfo->texture->flags & SURF_DRAWSKY)
{
out->shader = &Cshader_sky;
+ out->samples = NULL;
Mod_GenerateWarpMesh (out);
continue;
}
out->texturemins[i] = -8192*1024;
}
*/
+ out->samples = NULL;
Mod_GenerateWarpMesh (out);
continue;
}
{
// qbsp couldn't find the texture for this surface, but it was either turb or sky... assume turb
out->shader = &Cshader_water;
+ out->samples = NULL;
Mod_GenerateWarpMesh (out);
}
- else if (out->extents[0] < r_vertexsurfacesthreshold.integer && out->extents[1] < r_vertexsurfacesthreshold.integer)
+ else if ((out->extents[0]+1) > (256*16) || (out->extents[1]+1) > (256*16))
{
- out->shader = &Cshader_wall_vertex;
- Mod_GenerateVertexLitMesh(out);
+ Con_Printf ("Bad surface extents, converting to fullbright polygon");
+ out->shader = &Cshader_wall_fullbright;
+ out->samples = NULL;
+ Mod_GenerateVertexMesh(out);
}
else
{
- out->shader = &Cshader_wall_lightmap;
- Mod_GenerateLightmappedMesh(out);
+ // stainmap for permanent marks on walls
+ out->stainsamples = Mem_Alloc(loadmodel->mempool, ssize * tsize * 3);
+ // clear to white
+ memset(out->stainsamples, 255, ssize * tsize * 3);
+ if (out->extents[0] < r_vertexsurfacesthreshold.integer && out->extents[1] < r_vertexsurfacesthreshold.integer)
+ {
+ out->shader = &Cshader_wall_vertex;
+ Mod_GenerateVertexLitMesh(out);
+ }
+ else
+ {
+ out->shader = &Cshader_wall_lightmap;
+ Mod_GenerateLightmappedMesh(out);
+ }
}
}
}
typedef struct
{
int numpoints;
+ int padding;
double points[8][3]; // variable sized
}
winding_t;
-typedef struct
-{
- int numpoints;
-}
-windingsizeof_t;
-
/*
==================
NewWinding
int size;
if (points > MAX_POINTS_ON_WINDING)
- Host_Error("NewWinding: too many points\n");
+ Sys_Error("NewWinding: too many points\n");
- size = sizeof(windingsizeof_t) + sizeof(double[3]) * points;
- w = Mem_Alloc(tempmempool, size);
+ size = sizeof(winding_t) + sizeof(double[3]) * (points - 8);
+ w = Mem_Alloc(loadmodel->mempool, size);
memset (w, 0, size);
return w;
return in;
maxpts = in->numpoints+4; // can't use counts[0]+2 because of fp grouping errors
+ if (maxpts > MAX_POINTS_ON_WINDING)
+ Sys_Error ("ClipWinding: maxpts > MAX_POINTS_ON_WINDING");
+
neww = NewWinding (maxpts);
for (i = 0;i < in->numpoints;i++)
{
+ if (neww->numpoints >= maxpts)
+ Sys_Error ("ClipWinding: points exceeded estimate");
+
p1 = in->points[i];
if (sides[i] == SIDE_ON)
neww->numpoints++;
}
- if (neww->numpoints > maxpts)
- Host_Error ("ClipWinding: points exceeded estimate");
-
// free the original winding
FreeWinding (in);
+ // debugging
+ //Mem_CheckSentinels(neww);
+
return neww;
}
maxpts = in->numpoints+4; // can't use counts[0]+2 because of fp grouping errors
+ if (maxpts > MAX_POINTS_ON_WINDING)
+ Sys_Error ("ClipWinding: maxpts > MAX_POINTS_ON_WINDING");
+
*front = f = NewWinding (maxpts);
*back = b = NewWinding (maxpts);
for (i = 0;i < in->numpoints;i++)
{
+ if (f->numpoints >= maxpts || b->numpoints >= maxpts)
+ Sys_Error ("DivideWinding: points exceeded estimate");
+
p1 = in->points[i];
if (sides[i] == SIDE_ON)
b->numpoints++;
}
- if (f->numpoints > maxpts || b->numpoints > maxpts)
- Host_Error ("DivideWinding: points exceeded estimate");
+ // debugging
+ //Mem_CheckSentinels(f);
+ //Mem_CheckSentinels(b);
}
typedef struct portal_s
static portal_t *AllocPortal (void)
{
portal_t *p;
- p = Mem_Alloc(tempmempool, sizeof(portal_t));
+ p = Mem_Alloc(loadmodel->mempool, sizeof(portal_t));
//memset(p, 0, sizeof(portal_t));
p->chain = portalchain;
portalchain = p;
mleaf_t *leaf, *endleaf;
winding_t *w;
+ //Mem_CheckSentinelsGlobal();
+
// recalculate bounding boxes for all leafs (because qbsp is very sloppy)
leaf = loadmodel->leafs;
endleaf = leaf + loadmodel->numleafs;
for (;leaf < endleaf;leaf++)
{
- VectorSet( 2000000000, 2000000000, 2000000000, leaf->mins);
- VectorSet(-2000000000, -2000000000, -2000000000, leaf->maxs);
+ VectorSet(leaf->mins, 2000000000, 2000000000, 2000000000);
+ VectorSet(leaf->maxs, -2000000000, -2000000000, -2000000000);
}
p = portalchain;
while(p)
Mod_RecursiveRecalcNodeBBox(loadmodel->nodes);
+ //Mem_CheckSentinelsGlobal();
+
// tally up portal and point counts
p = portalchain;
numportals = 0;
FreePortal(p);
p = pnext;
}
+
+ //Mem_CheckSentinelsGlobal();
}
/*
nodeportal->plane = *node->plane;
nodeportalwinding = BaseWindingForPlane (node->plane);
+ //Mem_CheckSentinels(nodeportalwinding);
side = 0; // shut up compiler warning
for (portal = (portal_t *)node->portals;portal;portal = portal->next[side])
{
Cvar_SetValue("halflifebsp", mod->ishlbsp);
// swap all the lumps
- mod_base = (byte *)header;
+ mod_base = (qbyte *)header;
for (i=0 ; i<sizeof(dheader_t)/4 ; i++)
((int *)header)[i] = LittleLong ( ((int *)header)[i]);