}
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);
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");
}
}
}
}
+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;
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);
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]+1) > (256*16) || (out->extents[1]+1) > (256*16))
+ {
+ Con_Printf ("Bad surface extents, converting to fullbright polygon");
+ out->shader = &Cshader_wall_fullbright;
+ out->samples = NULL;
+ Mod_GenerateVertexMesh(out);
+ }
else if (out->extents[0] < r_vertexsurfacesthreshold.integer && out->extents[1] < r_vertexsurfacesthreshold.integer)
{
out->shader = &Cshader_wall_vertex;
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;
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])
{
projects / xonotic / darkplaces.git / blobdiff