#include "quakedef.h"
#include "image.h"
#include "r_shadow.h"
-#include "winding.h"
+#include "polygon.h"
#include "curves.h"
+#include "wad.h"
+
// note: model_shared.c sets up r_notexture, and r_surf_notexture
cvar_t r_lightmaprgba = {0, "r_lightmaprgba", "1"};
cvar_t r_nosurftextures = {0, "r_nosurftextures", "0"};
cvar_t r_subdivisions_tolerance = {0, "r_subdivisions_tolerance", "4"};
-cvar_t r_subdivisions_minlevel = {0, "r_subdivisions_minlevel", "0"};
-cvar_t r_subdivisions_maxlevel = {0, "r_subdivisions_maxlevel", "10"};
+cvar_t r_subdivisions_mintess = {0, "r_subdivisions_mintess", "1"};
+cvar_t r_subdivisions_maxtess = {0, "r_subdivisions_maxtess", "1024"};
cvar_t r_subdivisions_maxvertices = {0, "r_subdivisions_maxvertices", "65536"};
cvar_t r_subdivisions_collision_tolerance = {0, "r_subdivisions_collision_tolerance", "15"};
-cvar_t r_subdivisions_collision_minlevel = {0, "r_subdivisions_collision_minlevel", "0"};
-cvar_t r_subdivisions_collision_maxlevel = {0, "r_subdivisions_collision_maxlevel", "10"};
+cvar_t r_subdivisions_collision_mintess = {0, "r_subdivisions_collision_mintess", "1"};
+cvar_t r_subdivisions_collision_maxtess = {0, "r_subdivisions_collision_maxtess", "1024"};
cvar_t r_subdivisions_collision_maxvertices = {0, "r_subdivisions_collision_maxvertices", "4225"};
cvar_t mod_q3bsp_curves_collisions = {0, "mod_q3bsp_curves_collisions", "1"};
cvar_t mod_q3bsp_optimizedtraceline = {0, "mod_q3bsp_optimizedtraceline", "1"};
Cvar_RegisterVariable(&r_lightmaprgba);
Cvar_RegisterVariable(&r_nosurftextures);
Cvar_RegisterVariable(&r_subdivisions_tolerance);
- Cvar_RegisterVariable(&r_subdivisions_minlevel);
- Cvar_RegisterVariable(&r_subdivisions_maxlevel);
+ Cvar_RegisterVariable(&r_subdivisions_mintess);
+ Cvar_RegisterVariable(&r_subdivisions_maxtess);
Cvar_RegisterVariable(&r_subdivisions_maxvertices);
Cvar_RegisterVariable(&r_subdivisions_collision_tolerance);
- Cvar_RegisterVariable(&r_subdivisions_collision_minlevel);
- Cvar_RegisterVariable(&r_subdivisions_collision_maxlevel);
+ Cvar_RegisterVariable(&r_subdivisions_collision_mintess);
+ Cvar_RegisterVariable(&r_subdivisions_collision_maxtess);
Cvar_RegisterVariable(&r_subdivisions_collision_maxvertices);
Cvar_RegisterVariable(&mod_q3bsp_curves_collisions);
Cvar_RegisterVariable(&mod_q3bsp_optimizedtraceline);
leaf = Mod_Q1BSP_PointInLeaf(model, p);
if (leaf)
{
- i = min(outsize, (int)sizeof(leaf->ambient_sound_level));;
+ i = min(outsize, (int)sizeof(leaf->ambient_sound_level));
if (i)
{
memcpy(out, leaf->ambient_sound_level, i);
else
{
// box crosses plane, take one path and remember the other
- nodestack[nodestackindex++] = node->children[0];
+ if (nodestackindex < 1024)
+ nodestack[nodestackindex++] = node->children[0];
node = node->children[1];
}
}
int i, ds, dt;
msurface_t *surf;
- surf = cl.worldmodel->brushq1.surfaces + node->firstsurface;
+ surf = r_refdef.worldmodel->brushq1.surfaces + node->firstsurface;
for (i = 0;i < node->numsurfaces;i++, surf++)
{
if (!(surf->flags & SURF_LIGHTMAP) || !surf->samples)
void Mod_Q1BSP_LightPoint(model_t *model, const vec3_t p, vec3_t ambientcolor, vec3_t diffusecolor, vec3_t diffusenormal)
{
- Mod_Q1BSP_LightPoint_RecursiveBSPNode(ambientcolor, diffusecolor, diffusenormal, cl.worldmodel->brushq1.nodes + cl.worldmodel->brushq1.hulls[0].firstclipnode, p[0], p[1], p[2], p[2] - 65536);
+ Mod_Q1BSP_LightPoint_RecursiveBSPNode(ambientcolor, diffusecolor, diffusenormal, model->brushq1.nodes + model->brushq1.hulls[0].firstclipnode, p[0], p[1], p[2], p[2] - 65536);
}
static void Mod_Q1BSP_DecompressVis(const qbyte *in, const qbyte *inend, qbyte *out, qbyte *outend)
{
if (in == inend)
{
- Con_DPrintf("Mod_Q1BSP_DecompressVis: input underrun on model \"%s\" (decompressed %i of %i output bytes)\n", loadmodel->name, out - outstart, outend - outstart);
+ Con_Printf("Mod_Q1BSP_DecompressVis: input underrun on model \"%s\" (decompressed %i of %i output bytes)\n", loadmodel->name, out - outstart, outend - outstart);
return;
}
c = *in++;
{
if (in == inend)
{
- Con_DPrintf("Mod_Q1BSP_DecompressVis: input underrun (during zero-run) on model \"%s\" (decompressed %i of %i output bytes)\n", loadmodel->name, out - outstart, outend - outstart);
+ Con_Printf("Mod_Q1BSP_DecompressVis: input underrun (during zero-run) on model \"%s\" (decompressed %i of %i output bytes)\n", loadmodel->name, out - outstart, outend - outstart);
return;
}
for (c = *in++;c > 0;c--)
{
if (out == outend)
{
- Con_DPrintf("Mod_Q1BSP_DecompressVis: output overrun on model \"%s\" (decompressed %i of %i output bytes)\n", loadmodel->name, out - outstart, outend - outstart);
+ Con_Printf("Mod_Q1BSP_DecompressVis: output overrun on model \"%s\" (decompressed %i of %i output bytes)\n", loadmodel->name, out - outstart, outend - outstart);
return;
}
*out++ = 0;
}
}
+/*
+=============
+R_Q1BSP_LoadSplitSky
+
+A sky texture is 256*128, with the right side being a masked overlay
+==============
+*/
+void R_Q1BSP_LoadSplitSky (qbyte *src, int width, int height, int bytesperpixel)
+{
+ int i, j;
+ unsigned solidpixels[128*128], alphapixels[128*128];
+
+ // if sky isn't the right size, just use it as a solid layer
+ if (width != 256 || height != 128)
+ {
+ loadmodel->brush.solidskytexture = R_LoadTexture2D(loadmodel->texturepool, "sky_solidtexture", width, height, src, bytesperpixel == 4 ? TEXTYPE_RGBA : TEXTYPE_PALETTE, TEXF_PRECACHE, bytesperpixel == 1 ? palette_complete : NULL);
+ loadmodel->brush.alphaskytexture = NULL;;
+ return;
+ }
+
+ if (bytesperpixel == 4)
+ {
+ for (i = 0;i < 128;i++)
+ {
+ for (j = 0;j < 128;j++)
+ {
+ solidpixels[(i*128) + j] = ((unsigned *)src)[i*256+j+128];
+ alphapixels[(i*128) + j] = ((unsigned *)src)[i*256+j];
+ }
+ }
+ }
+ else
+ {
+ // make an average value for the back to avoid
+ // a fringe on the top level
+ int p, r, g, b;
+ union
+ {
+ unsigned int i;
+ unsigned char b[4];
+ }
+ rgba;
+ r = g = b = 0;
+ for (i = 0;i < 128;i++)
+ {
+ for (j = 0;j < 128;j++)
+ {
+ rgba.i = palette_complete[src[i*256 + j + 128]];
+ r += rgba.b[0];
+ g += rgba.b[1];
+ b += rgba.b[2];
+ }
+ }
+ rgba.b[0] = r/(128*128);
+ rgba.b[1] = g/(128*128);
+ rgba.b[2] = b/(128*128);
+ rgba.b[3] = 0;
+ for (i = 0;i < 128;i++)
+ {
+ for (j = 0;j < 128;j++)
+ {
+ solidpixels[(i*128) + j] = palette_complete[src[i*256 + j + 128]];
+ alphapixels[(i*128) + j] = (p = src[i*256 + j]) ? palette_complete[p] : rgba.i;
+ }
+ }
+ }
+
+ loadmodel->brush.solidskytexture = R_LoadTexture2D(loadmodel->texturepool, "sky_solidtexture", 128, 128, (qbyte *) solidpixels, TEXTYPE_RGBA, TEXF_PRECACHE, NULL);
+ loadmodel->brush.alphaskytexture = R_LoadTexture2D(loadmodel->texturepool, "sky_alphatexture", 128, 128, (qbyte *) alphapixels, TEXTYPE_RGBA, TEXF_ALPHA | TEXF_PRECACHE, NULL);
+}
+
static void Mod_Q1BSP_LoadTextures(lump_t *l)
{
int i, j, k, num, max, altmax, mtwidth, mtheight, *dofs, incomplete;
data = loadimagepixels(tx->name, false, 0, 0);
if (data)
{
- if (image_width == 256 && image_height == 128)
- {
- R_InitSky(data, 4);
- Mem_Free(data);
- }
- else
- {
- Mem_Free(data);
- Con_Printf("Invalid replacement texture for sky \"%s\" in %\"%s\", must be 256x128 pixels\n", tx->name, loadmodel->name);
- if (mtdata != NULL)
- R_InitSky(mtdata, 1);
- }
+ R_Q1BSP_LoadSplitSky(data, image_width, image_height, 4);
+ Mem_Free(data);
}
else if (mtdata != NULL)
- R_InitSky(mtdata, 1);
+ R_Q1BSP_LoadSplitSky(mtdata, mtwidth, mtheight, 1);
}
}
else
{
- if (!Mod_LoadSkinFrame(&tx->skin, tx->name, TEXF_MIPMAP | TEXF_ALPHA | TEXF_PRECACHE, false, true, true))
+ if (!Mod_LoadSkinFrame(&tx->skin, tx->name, TEXF_MIPMAP | TEXF_ALPHA | TEXF_PRECACHE | TEXF_PICMIP, false, true, true))
{
// did not find external texture, load it from the bsp or wad3
if (loadmodel->brush.ishlbsp)
{
tx->width = image_width;
tx->height = image_height;
- tx->skin.base = tx->skin.merged = R_LoadTexture2D(loadmodel->texturepool, tx->name, image_width, image_height, pixels, TEXTYPE_RGBA, TEXF_MIPMAP | TEXF_ALPHA | TEXF_PRECACHE, NULL);
+ tx->skin.base = tx->skin.merged = R_LoadTexture2D(loadmodel->texturepool, tx->name, image_width, image_height, pixels, TEXTYPE_RGBA, TEXF_MIPMAP | TEXF_ALPHA | TEXF_PRECACHE | TEXF_PICMIP, NULL);
if (Image_CheckAlpha(pixels, image_width * image_height, true))
{
fogpixels = Mem_Alloc(tempmempool, image_width * image_height * 4);
fogpixels[j + 2] = 255;
fogpixels[j + 3] = pixels[j + 3];
}
- tx->skin.fog = R_LoadTexture2D(loadmodel->texturepool, tx->name, image_width, image_height, pixels, TEXTYPE_RGBA, TEXF_MIPMAP | TEXF_ALPHA | TEXF_PRECACHE, NULL);
+ tx->skin.fog = R_LoadTexture2D(loadmodel->texturepool, tx->name, image_width, image_height, pixels, TEXTYPE_RGBA, TEXF_MIPMAP | TEXF_ALPHA | TEXF_PRECACHE | TEXF_PICMIP, NULL);
Mem_Free(fogpixels);
}
}
Mem_Free(freepixels);
}
else if (mtdata) // texture included
- Mod_LoadSkinFrame_Internal(&tx->skin, tx->name, TEXF_MIPMAP | TEXF_PRECACHE, false, true, tx->name[0] != '*' && r_fullbrights.integer, mtdata, tx->width, tx->height);
+ Mod_LoadSkinFrame_Internal(&tx->skin, tx->name, TEXF_MIPMAP | TEXF_PRECACHE | TEXF_PICMIP, false, true, tx->name[0] != '*' && r_fullbrights.integer, mtdata, tx->width, tx->height);
}
}
if (tx->skin.base == NULL)
if (loadmodel->brush.ishlbsp) // LordHavoc: load the colored lighting data straight
{
loadmodel->brushq1.lightdata = Mem_Alloc(loadmodel->mempool, l->filelen);
- memcpy(loadmodel->brushq1.lightdata, mod_base + l->fileofs, l->filelen);
+ for (i=0; i<l->filelen; i++)
+ loadmodel->brushq1.lightdata[i] = mod_base[l->fileofs+i] >>= 1;
}
else // LordHavoc: bsp version 29 (normal white lighting)
{
strlcpy (litfilename, loadmodel->name, sizeof (litfilename));
FS_StripExtension (litfilename, litfilename, sizeof (litfilename));
strlcat (litfilename, ".lit", sizeof (litfilename));
- data = (qbyte*) FS_LoadFile(litfilename, false);
+ data = (qbyte*) FS_LoadFile(litfilename, tempmempool, false);
if (data)
{
if (fs_filesize > 8 && data[0] == 'Q' && data[1] == 'L' && data[2] == 'I' && data[3] == 'T')
strlcpy (lightsfilename, loadmodel->name, sizeof (lightsfilename));
FS_StripExtension (lightsfilename, lightsfilename, sizeof(lightsfilename));
strlcat (lightsfilename, ".lights", sizeof (lightsfilename));
- s = lightsstring = (char *) FS_LoadFile(lightsfilename, false);
+ s = lightsstring = (char *) FS_LoadFile(lightsfilename, tempmempool, false);
if (s)
{
numlights = 0;
}
}
+static void Mod_Q1BSP_LoadMapBrushes(void)
+{
+#if 0
+// unfinished
+ int submodel, numbrushes;
+ qboolean firstbrush;
+ char *text, *maptext;
+ char mapfilename[MAX_QPATH];
+ FS_StripExtension (loadmodel->name, mapfilename, sizeof (mapfilename));
+ strlcat (mapfilename, ".map", sizeof (mapfilename));
+ maptext = (qbyte*) FS_LoadFile(mapfilename, tempmempool, false);
+ if (!maptext)
+ return;
+ text = maptext;
+ if (!COM_ParseToken(&data, false))
+ return; // error
+ submodel = 0;
+ for (;;)
+ {
+ if (!COM_ParseToken(&data, false))
+ break;
+ if (com_token[0] != '{')
+ return; // error
+ // entity
+ firstbrush = true;
+ numbrushes = 0;
+ maxbrushes = 256;
+ brushes = Mem_Alloc(loadmodel->mempool, maxbrushes * sizeof(mbrush_t));
+ for (;;)
+ {
+ if (!COM_ParseToken(&data, false))
+ return; // error
+ if (com_token[0] == '}')
+ break; // end of entity
+ if (com_token[0] == '{')
+ {
+ // brush
+ if (firstbrush)
+ {
+ if (submodel)
+ {
+ if (submodel > loadmodel->brush.numsubmodels)
+ {
+ Con_Printf("Mod_Q1BSP_LoadMapBrushes: .map has more submodels than .bsp!\n");
+ model = NULL;
+ }
+ else
+ model = loadmodel->brush.submodels[submodel];
+ }
+ else
+ model = loadmodel;
+ }
+ for (;;)
+ {
+ if (!COM_ParseToken(&data, false))
+ return; // error
+ if (com_token[0] == '}')
+ break; // end of brush
+ // each brush face should be this format:
+ // ( x y z ) ( x y z ) ( x y z ) texture scroll_s scroll_t rotateangle scale_s scale_t
+ // FIXME: support hl .map format
+ for (pointnum = 0;pointnum < 3;pointnum++)
+ {
+ COM_ParseToken(&data, false);
+ for (componentnum = 0;componentnum < 3;componentnum++)
+ {
+ COM_ParseToken(&data, false);
+ point[pointnum][componentnum] = atof(com_token);
+ }
+ COM_ParseToken(&data, false);
+ }
+ COM_ParseToken(&data, false);
+ strlcpy(facetexture, com_token, sizeof(facetexture));
+ COM_ParseToken(&data, false);
+ //scroll_s = atof(com_token);
+ COM_ParseToken(&data, false);
+ //scroll_t = atof(com_token);
+ COM_ParseToken(&data, false);
+ //rotate = atof(com_token);
+ COM_ParseToken(&data, false);
+ //scale_s = atof(com_token);
+ COM_ParseToken(&data, false);
+ //scale_t = atof(com_token);
+ TriangleNormal(point[0], point[1], point[2], planenormal);
+ VectorNormalizeDouble(planenormal);
+ planedist = DotProduct(point[0], planenormal);
+ //ChooseTexturePlane(planenormal, texturevector[0], texturevector[1]);
+ }
+ continue;
+ }
+ }
+ }
+#endif
+}
+
+
+#define MAX_PORTALPOINTS 64
+
typedef struct portal_s
{
mplane_t plane;
mnode_t *nodes[2]; // [0] = front side of plane
struct portal_s *next[2];
- winding_t *winding;
+ int numpoints;
+ double points[3*MAX_PORTALPOINTS];
struct portal_s *chain; // all portals are linked into a list
}
portal_t;
mportal_t *portal;
mvertex_t *point;
mleaf_t *leaf, *endleaf;
- winding_t *w;
// recalculate bounding boxes for all leafs(because qbsp is very sloppy)
leaf = loadmodel->brushq1.data_leafs;
p = portalchain;
while (p)
{
- if (p->winding)
+ if (p->numpoints >= 3)
{
for (i = 0;i < 2;i++)
{
leaf = (mleaf_t *)p->nodes[i];
- w = p->winding;
- for (j = 0;j < w->numpoints;j++)
+ for (j = 0;j < p->numpoints;j++)
{
- if (leaf->mins[0] > w->points[j][0]) leaf->mins[0] = w->points[j][0];
- if (leaf->mins[1] > w->points[j][1]) leaf->mins[1] = w->points[j][1];
- if (leaf->mins[2] > w->points[j][2]) leaf->mins[2] = w->points[j][2];
- if (leaf->maxs[0] < w->points[j][0]) leaf->maxs[0] = w->points[j][0];
- if (leaf->maxs[1] < w->points[j][1]) leaf->maxs[1] = w->points[j][1];
- if (leaf->maxs[2] < w->points[j][2]) leaf->maxs[2] = w->points[j][2];
+ if (leaf->mins[0] > p->points[j*3+0]) leaf->mins[0] = p->points[j*3+0];
+ if (leaf->mins[1] > p->points[j*3+1]) leaf->mins[1] = p->points[j*3+1];
+ if (leaf->mins[2] > p->points[j*3+2]) leaf->mins[2] = p->points[j*3+2];
+ if (leaf->maxs[0] < p->points[j*3+0]) leaf->maxs[0] = p->points[j*3+0];
+ if (leaf->maxs[1] < p->points[j*3+1]) leaf->maxs[1] = p->points[j*3+1];
+ if (leaf->maxs[2] < p->points[j*3+2]) leaf->maxs[2] = p->points[j*3+2];
}
}
}
{
// note: this check must match the one below or it will usually corrupt memory
// the nodes[0] != nodes[1] check is because leaf 0 is the shared solid leaf, it can have many portals inside with leaf 0 on both sides
- if (p->winding && p->nodes[0] != p->nodes[1]
+ if (p->numpoints >= 3 && p->nodes[0] != p->nodes[1]
&& p->nodes[0]->contents != CONTENTS_SOLID && p->nodes[1]->contents != CONTENTS_SOLID
&& p->nodes[0]->contents != CONTENTS_SKY && p->nodes[1]->contents != CONTENTS_SKY)
{
numportals += 2;
- numpoints += p->winding->numpoints * 2;
+ numpoints += p->numpoints * 2;
}
p = p->chain;
}
{
pnext = p->chain;
- if (p->winding)
+ if (p->numpoints >= 3)
{
// note: this check must match the one above or it will usually corrupt memory
// the nodes[0] != nodes[1] check is because leaf 0 is the shared solid leaf, it can have many portals inside with leaf 0 on both sides
{
// first make the back to front portal(forward portal)
portal->points = point;
- portal->numpoints = p->winding->numpoints;
+ portal->numpoints = p->numpoints;
portal->plane.dist = p->plane.dist;
VectorCopy(p->plane.normal, portal->plane.normal);
portal->here = (mleaf_t *)p->nodes[1];
// copy points
for (j = 0;j < portal->numpoints;j++)
{
- VectorCopy(p->winding->points[j], point->position);
+ VectorCopy(p->points + j*3, point->position);
point++;
}
PlaneClassify(&portal->plane);
// then make the front to back portal(backward portal)
portal->points = point;
- portal->numpoints = p->winding->numpoints;
+ portal->numpoints = p->numpoints;
portal->plane.dist = -p->plane.dist;
VectorNegate(p->plane.normal, portal->plane.normal);
portal->here = (mleaf_t *)p->nodes[0];
// copy points
for (j = portal->numpoints - 1;j >= 0;j--)
{
- VectorCopy(p->winding->points[j], point->position);
+ VectorCopy(p->points + j*3, point->position);
point++;
}
PlaneClassify(&portal->plane);
// advance to next portal
portal++;
}
- Winding_Free(p->winding);
}
FreePortal(p);
p = pnext;
static void Mod_Q1BSP_RecursiveNodePortals(mnode_t *node)
{
- int side;
+ int i, side;
mnode_t *front, *back, *other_node;
mplane_t clipplane, *plane;
portal_t *portal, *nextportal, *nodeportal, *splitportal, *temp;
- winding_t *nodeportalwinding, *frontwinding, *backwinding;
+ int numfrontpoints, numbackpoints;
+ double frontpoints[3*MAX_PORTALPOINTS], backpoints[3*MAX_PORTALPOINTS];
// if a leaf, we're done
if (node->contents)
nodeportal = AllocPortal();
nodeportal->plane = *plane;
- nodeportalwinding = Winding_NewFromPlane(nodeportal->plane.normal[0], nodeportal->plane.normal[1], nodeportal->plane.normal[2], nodeportal->plane.dist);
+ PolygonD_QuadForPlane(nodeportal->points, nodeportal->plane.normal[0], nodeportal->plane.normal[1], nodeportal->plane.normal[2], nodeportal->plane.dist, 1024.0*1024.0*1024.0);
+ nodeportal->numpoints = 4;
side = 0; // shut up compiler warning
for (portal = (portal_t *)node->portals;portal;portal = portal->next[side])
{
else
Host_Error("Mod_Q1BSP_RecursiveNodePortals: mislinked portal");
- nodeportalwinding = Winding_Clip(nodeportalwinding, clipplane.normal[0], clipplane.normal[1], clipplane.normal[2], clipplane.dist, true);
- if (!nodeportalwinding)
- {
- Con_Print("Mod_Q1BSP_RecursiveNodePortals: WARNING: new portal was clipped away\n");
+ for (i = 0;i < nodeportal->numpoints*3;i++)
+ frontpoints[i] = nodeportal->points[i];
+ PolygonD_Divide(nodeportal->numpoints, frontpoints, clipplane.normal[0], clipplane.normal[1], clipplane.normal[2], clipplane.dist, 1.0/32.0, MAX_PORTALPOINTS, nodeportal->points, &nodeportal->numpoints, 0, NULL, NULL);
+ if (nodeportal->numpoints <= 0 || nodeportal->numpoints >= MAX_PORTALPOINTS)
break;
- }
}
- if (nodeportalwinding)
+ if (nodeportal->numpoints < 3)
{
- // if the plane was not clipped on all sides, there was an error
- nodeportal->winding = nodeportalwinding;
- AddPortalToNodes(nodeportal, front, back);
+ Con_Print("Mod_Q1BSP_RecursiveNodePortals: WARNING: new portal was clipped away\n");
+ nodeportal->numpoints = 0;
}
-
- // split the portals of this node along this node's plane and assign them to the children of this node
- // (migrating the portals downward through the tree)
- for (portal = (portal_t *)node->portals;portal;portal = nextportal)
+ else if (nodeportal->numpoints >= MAX_PORTALPOINTS)
{
- if (portal->nodes[0] == portal->nodes[1])
- Host_Error("Mod_Q1BSP_RecursiveNodePortals: portal has same node on both sides(2)");
- if (portal->nodes[0] == node)
- side = 0;
- else if (portal->nodes[1] == node)
- side = 1;
- else
- Host_Error("Mod_Q1BSP_RecursiveNodePortals: mislinked portal");
- nextportal = portal->next[side];
-
- other_node = portal->nodes[!side];
- RemovePortalFromNodes(portal);
-
- // cut the portal into two portals, one on each side of the node plane
- Winding_Divide(portal->winding, plane->normal[0], plane->normal[1], plane->normal[2], plane->dist, &frontwinding, &backwinding);
+ Con_Print("Mod_Q1BSP_RecursiveNodePortals: WARNING: new portal has too many points\n");
+ nodeportal->numpoints = 0;
+ }
+ else
+ {
+ AddPortalToNodes(nodeportal, front, back);
- if (!frontwinding)
+ // split the portals of this node along this node's plane and assign them to the children of this node
+ // (migrating the portals downward through the tree)
+ for (portal = (portal_t *)node->portals;portal;portal = nextportal)
{
- if (side == 0)
- AddPortalToNodes(portal, back, other_node);
+ if (portal->nodes[0] == portal->nodes[1])
+ Host_Error("Mod_Q1BSP_RecursiveNodePortals: portal has same node on both sides(2)");
+ if (portal->nodes[0] == node)
+ side = 0;
+ else if (portal->nodes[1] == node)
+ side = 1;
else
- AddPortalToNodes(portal, other_node, back);
- continue;
- }
- if (!backwinding)
- {
+ Host_Error("Mod_Q1BSP_RecursiveNodePortals: mislinked portal");
+ nextportal = portal->next[side];
+
+ other_node = portal->nodes[!side];
+ RemovePortalFromNodes(portal);
+
+ // cut the portal into two portals, one on each side of the node plane
+ PolygonD_Divide(portal->numpoints, portal->points, plane->normal[0], plane->normal[1], plane->normal[2], plane->dist, 1.0/32.0, MAX_PORTALPOINTS, frontpoints, &numfrontpoints, MAX_PORTALPOINTS, backpoints, &numbackpoints);
+
+ if (!numfrontpoints)
+ {
+ if (side == 0)
+ AddPortalToNodes(portal, back, other_node);
+ else
+ AddPortalToNodes(portal, other_node, back);
+ continue;
+ }
+ if (!numbackpoints)
+ {
+ if (side == 0)
+ AddPortalToNodes(portal, front, other_node);
+ else
+ AddPortalToNodes(portal, other_node, front);
+ continue;
+ }
+
+ // the portal is split
+ splitportal = AllocPortal();
+ temp = splitportal->chain;
+ *splitportal = *portal;
+ splitportal->chain = temp;
+ for (i = 0;i < numbackpoints*3;i++)
+ splitportal->points[i] = backpoints[i];
+ splitportal->numpoints = numbackpoints;
+ for (i = 0;i < numfrontpoints*3;i++)
+ portal->points[i] = frontpoints[i];
+ portal->numpoints = numfrontpoints;
+
if (side == 0)
+ {
AddPortalToNodes(portal, front, other_node);
+ AddPortalToNodes(splitportal, back, other_node);
+ }
else
+ {
AddPortalToNodes(portal, other_node, front);
- continue;
- }
-
- // the winding is split
- splitportal = AllocPortal();
- temp = splitportal->chain;
- *splitportal = *portal;
- splitportal->chain = temp;
- splitportal->winding = backwinding;
- Winding_Free(portal->winding);
- portal->winding = frontwinding;
-
- if (side == 0)
- {
- AddPortalToNodes(portal, front, other_node);
- AddPortalToNodes(splitportal, back, other_node);
- }
- else
- {
- AddPortalToNodes(portal, other_node, front);
- AddPortalToNodes(splitportal, other_node, back);
+ AddPortalToNodes(splitportal, other_node, back);
+ }
}
}
int i, j, stylecounts[256], totalcount, remapstyles[256];
msurface_t *surf;
memset(stylecounts, 0, sizeof(stylecounts));
- for (i = 0;i < model->brushq1.nummodelsurfaces;i++)
+ for (i = 0;i < model->nummodelsurfaces;i++)
{
- surf = model->brushq1.surfaces + model->brushq1.firstmodelsurface + i;
+ surf = model->brushq1.surfaces + model->firstmodelsurface + i;
for (j = 0;j < MAXLIGHTMAPS;j++)
stylecounts[surf->styles[j]]++;
}
model->brushq1.light_styleupdatechains[i] = model->brushq1.light_styleupdatechainsbuffer + j;
j += stylecounts[model->brushq1.light_style[i]] + 1;
}
- for (i = 0;i < model->brushq1.nummodelsurfaces;i++)
+ for (i = 0;i < model->nummodelsurfaces;i++)
{
- surf = model->brushq1.surfaces + model->brushq1.firstmodelsurface + i;
+ surf = model->brushq1.surfaces + model->firstmodelsurface + i;
for (j = 0;j < MAXLIGHTMAPS;j++)
if (surf->styles[j] != 255)
*model->brushq1.light_styleupdatechains[remapstyles[surf->styles[j]]]++ = surf;
int i, j;
for (i = 0;i < model->brushq1.numtextures;i++)
model->brushq1.pvstexturechainslength[i] = 0;
- for (i = 0, j = model->brushq1.firstmodelsurface;i < model->brushq1.nummodelsurfaces;i++, j++)
+ for (i = 0, j = model->firstmodelsurface;i < model->nummodelsurfaces;i++, j++)
{
if (model->brushq1.surfacepvsframes[j] == model->brushq1.pvsframecount)
{
else
model->brushq1.pvstexturechains[i] = NULL;
}
- for (i = 0, j = model->brushq1.firstmodelsurface;i < model->brushq1.nummodelsurfaces;i++, j++)
+ for (i = 0, j = model->firstmodelsurface;i < model->nummodelsurfaces;i++, j++)
if (model->brushq1.surfacepvsframes[j] == model->brushq1.pvsframecount)
*model->brushq1.pvstexturechains[model->brushq1.surfaces[j].texinfo->texture->number]++ = model->brushq1.surfaces + j;
for (i = 0;i < model->brushq1.numtextures;i++)
}
*/
-extern void R_Model_Brush_DrawSky(entity_render_t *ent);
-extern void R_Model_Brush_Draw(entity_render_t *ent);
-extern void R_Model_Brush_GetLightInfo(entity_render_t *ent, vec3_t relativelightorigin, float lightradius, vec3_t outmins, vec3_t outmaxs, int *outclusterlist, qbyte *outclusterpvs, int *outnumclusterspointer, int *outsurfacelist, qbyte *outsurfacepvs, int *outnumsurfacespointer);
-extern void R_Model_Brush_DrawShadowVolume(entity_render_t *ent, vec3_t relativelightorigin, float lightradius, int numsurfaces, const int *surfacelist);
-extern void R_Model_Brush_DrawLight(entity_render_t *ent, vec3_t relativelightorigin, vec3_t relativeeyeorigin, float lightradius, float *lightcolor, const matrix4x4_t *matrix_modeltolight, const matrix4x4_t *matrix_modeltoattenuationxyz, const matrix4x4_t *matrix_modeltoattenuationz, rtexture_t *lightcubemap, int numsurfaces, const int *surfacelist);
+extern void R_Q1BSP_DrawSky(entity_render_t *ent);
+extern void R_Q1BSP_Draw(entity_render_t *ent);
+extern void R_Q1BSP_GetLightInfo(entity_render_t *ent, vec3_t relativelightorigin, float lightradius, vec3_t outmins, vec3_t outmaxs, int *outclusterlist, qbyte *outclusterpvs, int *outnumclusterspointer, int *outsurfacelist, qbyte *outsurfacepvs, int *outnumsurfacespointer);
+extern void R_Q1BSP_DrawShadowVolume(entity_render_t *ent, vec3_t relativelightorigin, float lightradius, int numsurfaces, const int *surfacelist);
+extern void R_Q1BSP_DrawLight(entity_render_t *ent, vec3_t relativelightorigin, vec3_t relativeeyeorigin, float lightradius, float *lightcolor, const matrix4x4_t *matrix_modeltolight, const matrix4x4_t *matrix_modeltoattenuationxyz, const matrix4x4_t *matrix_modeltoattenuationz, rtexture_t *lightcubemap, vec_t ambientscale, vec_t diffusescale, vec_t specularscale, int numsurfaces, const int *surfacelist);
void Mod_Q1BSP_Load(model_t *mod, void *buffer)
{
int i, j, k;
dheader_t *header;
dmodel_t *bm;
mempool_t *mainmempool;
- char *loadname;
- model_t *originalloadmodel;
float dist, modelyawradius, modelradius, *vec;
msurface_t *surf;
int numshadowmeshtriangles;
- mod->type = mod_brush;
+ mod->type = mod_brushq1;
header = (dheader_t *)buffer;
mod->brushq1.BuildPVSTextureChains = Mod_Q1BSP_BuildPVSTextureChains;
if (loadmodel->isworldmodel)
- {
Cvar_SetValue("halflifebsp", mod->brush.ishlbsp);
- // until we get a texture for it...
- R_ResetQuakeSky();
- }
// swap all the lumps
mod_base = (qbyte *)header;
- for (i = 0;i < (int) sizeof(dheader_t) / 4;i++)
- ((int *)header)[i] = LittleLong(((int *)header)[i]);
+ header->version = LittleLong(header->version);
+ for (i = 0;i < HEADER_LUMPS;i++)
+ {
+ header->lumps[i].fileofs = LittleLong(header->lumps[i].fileofs);
+ header->lumps[i].filelen = LittleLong(header->lumps[i].filelen);
+ }
// load into heap
Mod_Q1BSP_LoadNodes(&header->lumps[LUMP_NODES]);
Mod_Q1BSP_LoadClipnodes(&header->lumps[LUMP_CLIPNODES]);
+ if (!mod->brushq1.lightdata)
+ mod->brush.LightPoint = NULL;
+
if (mod->brushq1.data_compressedpvs)
Mem_Free(mod->brushq1.data_compressedpvs);
mod->brushq1.data_compressedpvs = NULL;
Mod_Q1BSP_MakePortals();
mod->numframes = 2; // regular and alternate animation
+ mod->numskins = 1;
mainmempool = mod->mempool;
- loadname = mod->name;
Mod_Q1BSP_LoadLightList();
- originalloadmodel = loadmodel;
// make a single combined shadow mesh to allow optimized shadow volume creation
numshadowmeshtriangles = 0;
Mod_ShadowMesh_AddMesh(loadmodel->mempool, loadmodel->brush.shadowmesh, NULL, NULL, NULL, surf->mesh.data_vertex3f, NULL, NULL, NULL, NULL, surf->mesh.num_triangles, surf->mesh.data_element3i);
loadmodel->brush.shadowmesh = Mod_ShadowMesh_Finish(loadmodel->mempool, loadmodel->brush.shadowmesh, false, true);
Mod_BuildTriangleNeighbors(loadmodel->brush.shadowmesh->neighbor3i, loadmodel->brush.shadowmesh->element3i, loadmodel->brush.shadowmesh->numtriangles);
-
-//
-// set up the submodels(FIXME: this is confusing)
-//
+
+ if (loadmodel->brush.numsubmodels)
+ loadmodel->brush.submodels = Mem_Alloc(loadmodel->mempool, loadmodel->brush.numsubmodels * sizeof(model_t *));
+
+ // LordHavoc: to clear the fog around the original quake submodel code, I
+ // will explain:
+ // first of all, some background info on the submodels:
+ // model 0 is the map model (the world, named maps/e1m1.bsp for example)
+ // model 1 and higher are submodels (doors and the like, named *1, *2, etc)
+ // now the weird for loop itself:
+ // the loop functions in an odd way, on each iteration it sets up the
+ // current 'mod' model (which despite the confusing code IS the model of
+ // the number i), at the end of the loop it duplicates the model to become
+ // the next submodel, and loops back to set up the new submodel.
+
+ // LordHavoc: now the explanation of my sane way (which works identically):
+ // set up the world model, then on each submodel copy from the world model
+ // and set up the submodel with the respective model info.
for (i = 0;i < mod->brush.numsubmodels;i++)
{
+ // LordHavoc: this code was originally at the end of this loop, but
+ // has been transformed to something more readable at the start here.
+
+ if (i > 0)
+ {
+ char name[10];
+ // LordHavoc: only register submodels if it is the world
+ // (prevents external bsp models from replacing world submodels with
+ // their own)
+ if (!loadmodel->isworldmodel)
+ continue;
+ // duplicate the basic information
+ sprintf(name, "*%i", i);
+ mod = Mod_FindName(name);
+ // copy the base model to this one
+ *mod = *loadmodel;
+ // rename the clone back to its proper name
+ strcpy(mod->name, name);
+ // textures and memory belong to the main model
+ mod->texturepool = NULL;
+ mod->mempool = NULL;
+ }
+
+ if (loadmodel->brush.submodels)
+ loadmodel->brush.submodels[i] = mod;
+
bm = &mod->brushq1.submodels[i];
mod->brushq1.hulls[0].firstclipnode = bm->headnode[0];
mod->brushq1.hulls[j].lastclipnode = mod->brushq1.numclipnodes - 1;
}
- mod->brushq1.firstmodelsurface = bm->firstface;
- mod->brushq1.nummodelsurfaces = bm->numfaces;
+ mod->firstmodelsurface = bm->firstface;
+ mod->nummodelsurfaces = bm->numfaces;
// make the model surface list (used by shadowing/lighting)
- mod->numsurfaces = mod->brushq1.nummodelsurfaces;
- mod->surfacelist = Mem_Alloc(originalloadmodel->mempool, mod->numsurfaces * sizeof(*mod->surfacelist));
- for (j = 0;j < mod->numsurfaces;j++)
- mod->surfacelist[j] = mod->brushq1.firstmodelsurface + j;
+ mod->surfacelist = Mem_Alloc(loadmodel->mempool, mod->nummodelsurfaces * sizeof(*mod->surfacelist));
+ for (j = 0;j < mod->nummodelsurfaces;j++)
+ mod->surfacelist[j] = mod->firstmodelsurface + j;
// this gets altered below if sky is used
mod->DrawSky = NULL;
- mod->Draw = R_Model_Brush_Draw;
- mod->GetLightInfo = R_Model_Brush_GetLightInfo;
- mod->DrawShadowVolume = R_Model_Brush_DrawShadowVolume;
- mod->DrawLight = R_Model_Brush_DrawLight;
+ mod->Draw = R_Q1BSP_Draw;
+ mod->GetLightInfo = R_Q1BSP_GetLightInfo;
+ mod->DrawShadowVolume = R_Q1BSP_DrawShadowVolume;
+ mod->DrawLight = R_Q1BSP_DrawLight;
if (i != 0)
{
mod->brush.GetPVS = NULL;
mod->brush.LightPoint = NULL;
mod->brush.AmbientSoundLevelsForPoint = NULL;
}
- mod->brushq1.pvstexturechains = Mem_Alloc(originalloadmodel->mempool, mod->brushq1.numtextures * sizeof(msurface_t **));
- mod->brushq1.pvstexturechainsbuffer = Mem_Alloc(originalloadmodel->mempool,(mod->brushq1.nummodelsurfaces + mod->brushq1.numtextures) * sizeof(msurface_t *));
- mod->brushq1.pvstexturechainslength = Mem_Alloc(originalloadmodel->mempool, mod->brushq1.numtextures * sizeof(int));
+ mod->brushq1.pvstexturechains = Mem_Alloc(loadmodel->mempool, mod->brushq1.numtextures * sizeof(msurface_t **));
+ mod->brushq1.pvstexturechainsbuffer = Mem_Alloc(loadmodel->mempool,(mod->nummodelsurfaces + mod->brushq1.numtextures) * sizeof(msurface_t *));
+ mod->brushq1.pvstexturechainslength = Mem_Alloc(loadmodel->mempool, mod->brushq1.numtextures * sizeof(int));
Mod_Q1BSP_BuildPVSTextureChains(mod);
- Mod_Q1BSP_BuildLightmapUpdateChains(originalloadmodel->mempool, mod);
- if (mod->brushq1.nummodelsurfaces)
+ Mod_Q1BSP_BuildLightmapUpdateChains(loadmodel->mempool, mod);
+ if (mod->nummodelsurfaces)
{
// LordHavoc: calculate bmodel bounding box rather than trusting what it says
mod->normalmins[0] = mod->normalmins[1] = mod->normalmins[2] = 1000000000.0f;
mod->normalmaxs[0] = mod->normalmaxs[1] = mod->normalmaxs[2] = -1000000000.0f;
modelyawradius = 0;
modelradius = 0;
- for (j = 0, surf = &mod->brushq1.surfaces[mod->brushq1.firstmodelsurface];j < mod->brushq1.nummodelsurfaces;j++, surf++)
+ for (j = 0, surf = &mod->brushq1.surfaces[mod->firstmodelsurface];j < mod->nummodelsurfaces;j++, surf++)
{
// we only need to have a drawsky function if it is used(usually only on world model)
if (surf->texinfo->texture->flags & SURF_DRAWSKY)
- mod->DrawSky = R_Model_Brush_DrawSky;
+ mod->DrawSky = R_Q1BSP_DrawSky;
// LordHavoc: submodels always clip, even if water
if (mod->brush.numsubmodels - 1)
surf->flags |= SURF_SOLIDCLIP;
else
{
// LordHavoc: empty submodel(lacrima.bsp has such a glitch)
- Con_Printf("warning: empty submodel *%i in %s\n", i+1, loadname);
+ Con_Printf("warning: empty submodel *%i in %s\n", i+1, loadmodel->name);
}
- Mod_Q1BSP_BuildSurfaceNeighbors(mod->brushq1.surfaces + mod->brushq1.firstmodelsurface, mod->brushq1.nummodelsurfaces, originalloadmodel->mempool);
+ Mod_Q1BSP_BuildSurfaceNeighbors(mod->brushq1.surfaces + mod->firstmodelsurface, mod->nummodelsurfaces, loadmodel->mempool);
mod->brushq1.num_visleafs = bm->visleafs;
-
- // LordHavoc: only register submodels if it is the world
- // (prevents bsp models from replacing world submodels)
- if (loadmodel->isworldmodel && i < (mod->brush.numsubmodels - 1))
- {
- char name[10];
- // duplicate the basic information
- sprintf(name, "*%i", i+1);
- loadmodel = Mod_FindName(name);
- *loadmodel = *mod;
- strcpy(loadmodel->name, name);
- // textures and memory belong to the main model
- loadmodel->texturepool = NULL;
- loadmodel->mempool = NULL;
- mod = loadmodel;
- }
}
- loadmodel = originalloadmodel;
+ Mod_Q1BSP_LoadMapBrushes();
+
//Mod_Q1BSP_ProcessLightList();
if (developer.integer)
Host_Error("Mod_Q2BSP_Load: %s has wrong version number (%i, should be %i)", mod->name, i, Q2BSPVERSION);
mod->brush.ishlbsp = false;
if (loadmodel->isworldmodel)
- {
Cvar_SetValue("halflifebsp", mod->brush.ishlbsp);
- // until we get a texture for it...
- R_ResetQuakeSky();
- }
mod_base = (qbyte *)header;
fssearch_t *search;
char *f;
const char *text;
- int flags;
+ int flags, flags2, numparameters, passnumber;
char shadername[Q3PATHLENGTH];
char sky[Q3PATHLENGTH];
+ char firstpasstexturename[Q3PATHLENGTH];
+ char parameter[4][Q3PATHLENGTH];
in = (void *)(mod_base + l->fileofs);
if (l->filelen % sizeof(*in))
out->surfaceflags = LittleLong(in->surfaceflags);
out->nativecontents = LittleLong(in->contents);
out->supercontents = Mod_Q3BSP_SuperContentsFromNativeContents(loadmodel, out->nativecontents);
- Mod_LoadSkinFrame(&out->skin, out->name, TEXF_MIPMAP | TEXF_ALPHA | TEXF_PRECACHE, false, true, true);
out->surfaceparms = -1;
}
{
for (i = 0;i < search->numfilenames;i++)
{
- if ((f = FS_LoadFile(search->filenames[i], false)))
+ if ((f = FS_LoadFile(search->filenames[i], tempmempool, false)))
{
text = f;
while (COM_ParseToken(&text, false))
{
- strncpy(shadername, com_token, sizeof(shadername));
+ strlcpy (shadername, com_token, sizeof (shadername));
flags = 0;
+ flags2 = 0;
sky[0] = 0;
+ passnumber = 0;
+ firstpasstexturename[0] = 0;
if (COM_ParseToken(&text, false) && !strcasecmp(com_token, "{"))
{
while (COM_ParseToken(&text, false))
{
if (!strcasecmp(com_token, "}"))
break;
+ if (!strcasecmp(com_token, "\n"))
+ continue;
+ numparameters = 0;
+ for (j = 0;strcasecmp(com_token, "\n") && strcasecmp(com_token, "}");j++)
+ {
+ if (j < 4)
+ {
+ strlcpy(parameter[j], com_token, sizeof(parameter[j]));
+ numparameters = j + 1;
+ }
+ if (!COM_ParseToken(&text, true))
+ break;
+ }
+ if (developer.integer >= 2)
+ {
+ Con_Printf("%s %i: ", shadername, passnumber);
+ for (j = 0;j < numparameters;j++)
+ Con_Printf(" %s", parameter[j]);
+ Con_Print("\n");
+ }
+ if (passnumber == 0 && numparameters >= 1)
+ {
+ if (!strcasecmp(parameter[0], "blendfunc"))
+ {
+ if (numparameters == 2 && !strcasecmp(parameter[1], "add"))
+ flags2 |= Q3TEXTUREFLAG_ADDITIVE;
+ else if (numparameters == 3 && !strcasecmp(parameter[1], "gl_one") && !strcasecmp(parameter[2], "gl_one"))
+ flags2 |= Q3TEXTUREFLAG_ADDITIVE;
+ else if (numparameters == 3 && !strcasecmp(parameter[1], "gl_src_alpha") && !strcasecmp(parameter[2], "gl_one"))
+ flags2 |= Q3TEXTUREFLAG_ADDITIVE;
+ }
+ else if (numparameters >= 2 && (!strcasecmp(parameter[0], "map") || !strcasecmp(parameter[0], "clampmap")))
+ strlcpy(firstpasstexturename, parameter[1], sizeof(firstpasstexturename));
+ else if (numparameters >= 3 && !strcasecmp(parameter[0], "animmap"))
+ strlcpy(firstpasstexturename, parameter[2], sizeof(firstpasstexturename));
+ }
+ if (!strcasecmp(parameter[0], "alphafunc"))
+ flags2 |= Q3TEXTUREFLAG_ALPHATEST;
+ // break out a level if it was }
+ if (!strcasecmp(com_token, "}"))
+ break;
}
+ passnumber++;
+ continue;
}
- else if (!strcasecmp(com_token, "surfaceparm"))
+ numparameters = 0;
+ for (j = 0;strcasecmp(com_token, "\n") && strcasecmp(com_token, "}");j++)
{
- if (COM_ParseToken(&text, true) && strcasecmp(com_token, "\n"))
+ if (j < 4)
{
- if (!strcasecmp(com_token, "alphashadow"))
- flags |= Q3SURFACEPARM_ALPHASHADOW;
- else if (!strcasecmp(com_token, "areaportal"))
- flags |= Q3SURFACEPARM_AREAPORTAL;
- else if (!strcasecmp(com_token, "clusterportal"))
- flags |= Q3SURFACEPARM_CLUSTERPORTAL;
- else if (!strcasecmp(com_token, "detail"))
- flags |= Q3SURFACEPARM_DETAIL;
- else if (!strcasecmp(com_token, "donotenter"))
- flags |= Q3SURFACEPARM_DONOTENTER;
- else if (!strcasecmp(com_token, "fog"))
- flags |= Q3SURFACEPARM_FOG;
- else if (!strcasecmp(com_token, "lava"))
- flags |= Q3SURFACEPARM_LAVA;
- else if (!strcasecmp(com_token, "lightfilter"))
- flags |= Q3SURFACEPARM_LIGHTFILTER;
- else if (!strcasecmp(com_token, "metalsteps"))
- flags |= Q3SURFACEPARM_METALSTEPS;
- else if (!strcasecmp(com_token, "nodamage"))
- flags |= Q3SURFACEPARM_NODAMAGE;
- else if (!strcasecmp(com_token, "nodlight"))
- flags |= Q3SURFACEPARM_NODLIGHT;
- else if (!strcasecmp(com_token, "nodraw"))
- flags |= Q3SURFACEPARM_NODRAW;
- else if (!strcasecmp(com_token, "nodrop"))
- flags |= Q3SURFACEPARM_NODROP;
- else if (!strcasecmp(com_token, "noimpact"))
- flags |= Q3SURFACEPARM_NOIMPACT;
- else if (!strcasecmp(com_token, "nolightmap"))
- flags |= Q3SURFACEPARM_NOLIGHTMAP;
- else if (!strcasecmp(com_token, "nomarks"))
- flags |= Q3SURFACEPARM_NOMARKS;
- else if (!strcasecmp(com_token, "nomipmaps"))
- flags |= Q3SURFACEPARM_NOMIPMAPS;
- else if (!strcasecmp(com_token, "nonsolid"))
- flags |= Q3SURFACEPARM_NONSOLID;
- else if (!strcasecmp(com_token, "origin"))
- flags |= Q3SURFACEPARM_ORIGIN;
- else if (!strcasecmp(com_token, "playerclip"))
- flags |= Q3SURFACEPARM_PLAYERCLIP;
- else if (!strcasecmp(com_token, "sky"))
- flags |= Q3SURFACEPARM_SKY;
- else if (!strcasecmp(com_token, "slick"))
- flags |= Q3SURFACEPARM_SLICK;
- else if (!strcasecmp(com_token, "slime"))
- flags |= Q3SURFACEPARM_SLIME;
- else if (!strcasecmp(com_token, "structural"))
- flags |= Q3SURFACEPARM_STRUCTURAL;
- else if (!strcasecmp(com_token, "trans"))
- flags |= Q3SURFACEPARM_TRANS;
- else if (!strcasecmp(com_token, "water"))
- flags |= Q3SURFACEPARM_WATER;
- else
- Con_Printf("%s parsing warning: unknown surfaceparm \"%s\"\n", search->filenames[i], com_token);
- if (!COM_ParseToken(&text, true) || strcasecmp(com_token, "\n"))
- {
- Con_Printf("%s parsing error: surfaceparm only takes one parameter.\n", search->filenames[i]);
- goto parseerror;
- }
+ strlcpy(parameter[j], com_token, sizeof(parameter[j]));
+ numparameters = j + 1;
}
+ if (!COM_ParseToken(&text, true))
+ break;
+ }
+ if (i == 0 && !strcasecmp(com_token, "}"))
+ break;
+ if (developer.integer >= 2)
+ {
+ Con_Printf("%s: ", shadername);
+ for (j = 0;j < numparameters;j++)
+ Con_Printf(" %s", parameter[j]);
+ Con_Print("\n");
+ }
+ if (numparameters < 1)
+ continue;
+ if (!strcasecmp(parameter[0], "surfaceparm") && numparameters >= 2)
+ {
+ if (!strcasecmp(parameter[1], "alphashadow"))
+ flags |= Q3SURFACEPARM_ALPHASHADOW;
+ else if (!strcasecmp(parameter[1], "areaportal"))
+ flags |= Q3SURFACEPARM_AREAPORTAL;
+ else if (!strcasecmp(parameter[1], "clusterportal"))
+ flags |= Q3SURFACEPARM_CLUSTERPORTAL;
+ else if (!strcasecmp(parameter[1], "detail"))
+ flags |= Q3SURFACEPARM_DETAIL;
+ else if (!strcasecmp(parameter[1], "donotenter"))
+ flags |= Q3SURFACEPARM_DONOTENTER;
+ else if (!strcasecmp(parameter[1], "fog"))
+ flags |= Q3SURFACEPARM_FOG;
+ else if (!strcasecmp(parameter[1], "lava"))
+ flags |= Q3SURFACEPARM_LAVA;
+ else if (!strcasecmp(parameter[1], "lightfilter"))
+ flags |= Q3SURFACEPARM_LIGHTFILTER;
+ else if (!strcasecmp(parameter[1], "metalsteps"))
+ flags |= Q3SURFACEPARM_METALSTEPS;
+ else if (!strcasecmp(parameter[1], "nodamage"))
+ flags |= Q3SURFACEPARM_NODAMAGE;
+ else if (!strcasecmp(parameter[1], "nodlight"))
+ flags |= Q3SURFACEPARM_NODLIGHT;
+ else if (!strcasecmp(parameter[1], "nodraw"))
+ flags |= Q3SURFACEPARM_NODRAW;
+ else if (!strcasecmp(parameter[1], "nodrop"))
+ flags |= Q3SURFACEPARM_NODROP;
+ else if (!strcasecmp(parameter[1], "noimpact"))
+ flags |= Q3SURFACEPARM_NOIMPACT;
+ else if (!strcasecmp(parameter[1], "nolightmap"))
+ flags |= Q3SURFACEPARM_NOLIGHTMAP;
+ else if (!strcasecmp(parameter[1], "nomarks"))
+ flags |= Q3SURFACEPARM_NOMARKS;
+ else if (!strcasecmp(parameter[1], "nomipmaps"))
+ flags |= Q3SURFACEPARM_NOMIPMAPS;
+ else if (!strcasecmp(parameter[1], "nonsolid"))
+ flags |= Q3SURFACEPARM_NONSOLID;
+ else if (!strcasecmp(parameter[1], "origin"))
+ flags |= Q3SURFACEPARM_ORIGIN;
+ else if (!strcasecmp(parameter[1], "playerclip"))
+ flags |= Q3SURFACEPARM_PLAYERCLIP;
+ else if (!strcasecmp(parameter[1], "sky"))
+ flags |= Q3SURFACEPARM_SKY;
+ else if (!strcasecmp(parameter[1], "slick"))
+ flags |= Q3SURFACEPARM_SLICK;
+ else if (!strcasecmp(parameter[1], "slime"))
+ flags |= Q3SURFACEPARM_SLIME;
+ else if (!strcasecmp(parameter[1], "structural"))
+ flags |= Q3SURFACEPARM_STRUCTURAL;
+ else if (!strcasecmp(parameter[1], "trans"))
+ flags |= Q3SURFACEPARM_TRANS;
+ else if (!strcasecmp(parameter[1], "water"))
+ flags |= Q3SURFACEPARM_WATER;
else
- {
- Con_Printf("%s parsing error: surfaceparm expects a parameter.\n", search->filenames[i]);
- goto parseerror;
- }
+ Con_Printf("%s parsing warning: unknown surfaceparm \"%s\"\n", search->filenames[i], parameter[1]);
}
- else if (!strcasecmp(com_token, "sky"))
+ else if (!strcasecmp(parameter[0], "sky") && numparameters >= 2)
+ strlcpy(sky, parameter[1], sizeof(sky));
+ else if (!strcasecmp(parameter[0], "skyparms") && numparameters >= 2)
{
- if (COM_ParseToken(&text, true) && strcasecmp(com_token, "\n"))
- if (strlen(com_token) < sizeof(sky))
- strcpy(sky, com_token);
+ if (!atoi(parameter[1]) && strcasecmp(parameter[1], "-"))
+ strlcpy(sky, parameter[1], sizeof(sky));
}
- else if (!strcasecmp(com_token, "skyparms"))
+ else if (!strcasecmp(parameter[0], "cull") && numparameters >= 2)
{
- if (COM_ParseToken(&text, true) && strcasecmp(com_token, "\n"))
- {
- if (strlen(com_token) < sizeof(sky) && !atoi(com_token) && strcasecmp(com_token, "-"))
- strcpy(sky, com_token);
- if (COM_ParseToken(&text, true) && strcasecmp(com_token, "\n"))
- COM_ParseToken(&text, true);
- }
+ if (!strcasecmp(parameter[1], "disable") || !strcasecmp(parameter[1], "none") || !strcasecmp(parameter[1], "twosided"))
+ flags2 |= Q3TEXTUREFLAG_TWOSIDED;
}
- else
+ else if (!strcasecmp(parameter[0], "nomipmaps"))
+ flags2 |= Q3TEXTUREFLAG_NOMIPMAPS;
+ else if (!strcasecmp(parameter[0], "nopicmip"))
+ flags2 |= Q3TEXTUREFLAG_NOPICMIP;
+ else if (!strcasecmp(parameter[0], "deformvertexes") && numparameters >= 2)
{
- // look for linebreak or }
- while(COM_ParseToken(&text, true) && strcasecmp(com_token, "\n") && strcasecmp(com_token, "}"));
- // break out to top level if it was }
- if (!strcasecmp(com_token, "}"))
- break;
+ if (!strcasecmp(parameter[1], "autosprite") && numparameters == 2)
+ flags2 |= Q3TEXTUREFLAG_AUTOSPRITE;
+ if (!strcasecmp(parameter[1], "autosprite2") && numparameters == 2)
+ flags2 |= Q3TEXTUREFLAG_AUTOSPRITE2;
}
}
+ // force transparent render path for a number of odd
+ // shader effects to avoid bogging down the normal
+ // render path unnecessarily
+ if (flags2 & (Q3TEXTUREFLAG_ADDITIVE | Q3TEXTUREFLAG_AUTOSPRITE | Q3TEXTUREFLAG_AUTOSPRITE2 | Q3TEXTUREFLAG_ALPHATEST))
+ flags |= Q3SURFACEPARM_TRANS;
// add shader to list (shadername and flags)
// actually here we just poke into the texture settings
for (j = 0, out = loadmodel->brushq3.data_textures;j < loadmodel->brushq3.num_textures;j++, out++)
if (!strcasecmp(out->name, shadername))
{
out->surfaceparms = flags;
+ out->textureflags = flags2;
+ strlcpy(out->firstpasstexturename, firstpasstexturename, sizeof(out->firstpasstexturename));
if ((flags & Q3SURFACEPARM_SKY) && sky[0])
- strcpy(loadmodel->brush.skybox, sky);
+ {
+ // quake3 seems to append a _ to the skybox name, so this must do so as well
+ snprintf(loadmodel->brush.skybox, sizeof(loadmodel->brush.skybox), "%s_", sky);
+ }
}
}
}
Con_DPrintf("%s: No shader found for texture \"%s\"\n", loadmodel->name, out->name);
out->surfaceparms = 0;
// these are defaults
- if (!strcmp(out->name, "caulk") || !strcmp(out->name, "common/caulk") || !strcmp(out->name, "textures/common/caulk")
- || !strcmp(out->name, "nodraw") || !strcmp(out->name, "common/nodraw") || !strcmp(out->name, "textures/common/nodraw"))
- out->surfaceparms |= Q3SURFACEPARM_NODRAW;
- if (!strncmp(out->name, "textures/skies/", 15))
- out->surfaceparms |= Q3SURFACEPARM_SKY;
- if (R_TextureHasAlpha(out->skin.base))
- out->surfaceparms |= Q3SURFACEPARM_TRANS;
+ //if (!strncmp(out->name, "textures/skies/", 15))
+ // out->surfaceparms |= Q3SURFACEPARM_SKY;
+ //if (!strcmp(out->name, "caulk") || !strcmp(out->name, "common/caulk") || !strcmp(out->name, "textures/common/caulk")
+ // || !strcmp(out->name, "nodraw") || !strcmp(out->name, "common/nodraw") || !strcmp(out->name, "textures/common/nodraw"))
+ // out->surfaceparms |= Q3SURFACEPARM_NODRAW;
+ //if (R_TextureHasAlpha(out->skin.base))
+ // out->surfaceparms |= Q3SURFACEPARM_TRANS;
}
+ if (!Mod_LoadSkinFrame(&out->skin, out->name, (((out->textureflags & Q3TEXTUREFLAG_NOMIPMAPS) || (out->surfaceparms & Q3SURFACEPARM_NOMIPMAPS)) ? 0 : TEXF_MIPMAP) | TEXF_ALPHA | TEXF_PRECACHE | (out->textureflags & Q3TEXTUREFLAG_NOPICMIP ? 0 : TEXF_PICMIP), false, true, true))
+ if (!Mod_LoadSkinFrame(&out->skin, out->firstpasstexturename, (((out->textureflags & Q3TEXTUREFLAG_NOMIPMAPS) || (out->surfaceparms & Q3SURFACEPARM_NOMIPMAPS)) ? 0 : TEXF_MIPMAP) | TEXF_ALPHA | TEXF_PRECACHE | (out->textureflags & Q3TEXTUREFLAG_NOPICMIP ? 0 : TEXF_PICMIP), false, true, true))
+ Con_Printf("%s: texture loading for shader \"%s\" failed (first layer \"%s\" not found either)\n", loadmodel->name, out->name, out->firstpasstexturename);
}
- Con_DPrintf("%s: %i textures missing shaders\n", loadmodel->name, c);
+ if (c)
+ Con_DPrintf("%s: %i textures missing shaders\n", loadmodel->name, c);
}
static void Mod_Q3BSP_LoadPlanes(lump_t *l)
q3mbrush_t *out;
int i, j, n, c, count, maxplanes;
mplane_t *planes;
- winding_t *temp1, *temp2;
in = (void *)(mod_base + l->fileofs);
if (l->filelen % sizeof(*in))
loadmodel->brushq3.data_brushes = out;
loadmodel->brushq3.num_brushes = count;
- temp1 = Winding_New(64);
- temp2 = Winding_New(64);
-
maxplanes = 0;
planes = NULL;
planes[j].dist = out->firstbrushside[j].plane->dist;
}
// make the colbrush from the planes
- out->colbrushf = Collision_NewBrushFromPlanes(loadmodel->mempool, out->numbrushsides, planes, out->texture->supercontents, temp1, temp2);
+ out->colbrushf = Collision_NewBrushFromPlanes(loadmodel->mempool, out->numbrushsides, planes, out->texture->supercontents);
}
if (planes)
Mem_Free(planes);
- Winding_Free(temp1);
- Winding_Free(temp2);
}
static void Mod_Q3BSP_LoadEffects(lump_t *l)
static void Mod_Q3BSP_LoadFaces(lump_t *l)
{
q3dface_t *in;
- q3mface_t *out;
- int i, j, n, count, invalidelements, patchsize[2], finalwidth, finalheight, xlevel, ylevel, row0, row1, x, y, *e, finalvertices, finaltriangles;
+ q3msurface_t *out;
+ int i, j, n, count, invalidelements, patchsize[2], finalwidth, finalheight, xtess, ytess, finalvertices, finaltriangles, firstvertex, firstelement, type, oldnumtriangles, oldnumtriangles2;
//int *originalelement3i;
//int *originalneighbor3i;
float *originalvertex3f;
for (i = 0;i < count;i++, in++, out++)
{
// check face type first
- out->type = LittleLong(in->type);
- if (out->type != Q3FACETYPE_POLYGON
- && out->type != Q3FACETYPE_PATCH
- && out->type != Q3FACETYPE_MESH
- && out->type != Q3FACETYPE_FLARE)
+ type = LittleLong(in->type);
+ if (type != Q3FACETYPE_POLYGON
+ && type != Q3FACETYPE_PATCH
+ && type != Q3FACETYPE_MESH
+ && type != Q3FACETYPE_FLARE)
{
- Con_DPrintf("Mod_Q3BSP_LoadFaces: face #%i: unknown face type %i\n", i, out->type);
+ Con_DPrintf("Mod_Q3BSP_LoadFaces: face #%i: unknown face type %i\n", i, type);
out->num_vertices = 0;
out->num_triangles = 0;
- out->type = 0; // error
+ type = 0; // error
continue;
}
Con_DPrintf("Mod_Q3BSP_LoadFaces: face #%i: invalid textureindex %i (%i textures)\n", i, n, loadmodel->brushq3.num_textures);
out->num_vertices = 0;
out->num_triangles = 0;
- out->type = 0; // error
+ type = 0; // error
continue;
n = 0;
}
n = LittleLong(in->effectindex);
if (n < -1 || n >= loadmodel->brushq3.num_effects)
{
- Con_DPrintf("Mod_Q3BSP_LoadFaces: face #%i (texture \"%s\"): invalid effectindex %i (%i effects)\n", i, out->texture->name, n, loadmodel->brushq3.num_effects);
+ if (developer.integer >= 2)
+ Con_Printf("Mod_Q3BSP_LoadFaces: face #%i (texture \"%s\"): invalid effectindex %i (%i effects)\n", i, out->texture->name, n, loadmodel->brushq3.num_effects);
n = -1;
}
if (n == -1)
else
out->effect = loadmodel->brushq3.data_effects + n;
n = LittleLong(in->lightmapindex);
- if (n < -1 || n >= loadmodel->brushq3.num_lightmaps)
+ if (n >= loadmodel->brushq3.num_lightmaps)
{
- Con_DPrintf("Mod_Q3BSP_LoadFaces: face #%i (texture \"%s\"): invalid lightmapindex %i (%i lightmaps)\n", i, out->texture->name, n, loadmodel->brushq3.num_lightmaps);
+ Con_Printf("Mod_Q3BSP_LoadFaces: face #%i (texture \"%s\"): invalid lightmapindex %i (%i lightmaps)\n", i, out->texture->name, n, loadmodel->brushq3.num_lightmaps);
n = -1;
}
+ else if (n < 0)
+ n = -1;
if (n == -1)
out->lightmaptexture = NULL;
else
out->lightmaptexture = loadmodel->brushq3.data_lightmaps[n];
- out->firstvertex = LittleLong(in->firstvertex);
+ firstvertex = LittleLong(in->firstvertex);
out->num_vertices = LittleLong(in->numvertices);
- out->firstelement = LittleLong(in->firstelement);
+ firstelement = LittleLong(in->firstelement);
out->num_triangles = LittleLong(in->numelements) / 3;
if (out->num_triangles * 3 != LittleLong(in->numelements))
{
Con_Printf("Mod_Q3BSP_LoadFaces: face #%i (texture \"%s\"): numelements %i is not a multiple of 3\n", i, out->texture->name, LittleLong(in->numelements));
out->num_vertices = 0;
out->num_triangles = 0;
- out->type = 0; // error
+ type = 0; // error
continue;
}
- if (out->firstvertex < 0 || out->firstvertex + out->num_vertices > loadmodel->brushq3.num_vertices)
+ if (firstvertex < 0 || firstvertex + out->num_vertices > loadmodel->brushq3.num_vertices)
{
- Con_Printf("Mod_Q3BSP_LoadFaces: face #%i (texture \"%s\"): invalid vertex range %i : %i (%i vertices)\n", i, out->texture->name, out->firstvertex, out->firstvertex + out->num_vertices, loadmodel->brushq3.num_vertices);
+ Con_Printf("Mod_Q3BSP_LoadFaces: face #%i (texture \"%s\"): invalid vertex range %i : %i (%i vertices)\n", i, out->texture->name, firstvertex, firstvertex + out->num_vertices, loadmodel->brushq3.num_vertices);
out->num_vertices = 0;
out->num_triangles = 0;
- out->type = 0; // error
+ type = 0; // error
continue;
}
- if (out->firstelement < 0 || out->firstelement + out->num_triangles * 3 > loadmodel->brushq3.num_triangles * 3)
+ if (firstelement < 0 || firstelement + out->num_triangles * 3 > loadmodel->brushq3.num_triangles * 3)
{
- Con_Printf("Mod_Q3BSP_LoadFaces: face #%i (texture \"%s\"): invalid element range %i : %i (%i elements)\n", i, out->texture->name, out->firstelement, out->firstelement + out->num_triangles * 3, loadmodel->brushq3.num_triangles * 3);
+ Con_Printf("Mod_Q3BSP_LoadFaces: face #%i (texture \"%s\"): invalid element range %i : %i (%i elements)\n", i, out->texture->name, firstelement, firstelement + out->num_triangles * 3, loadmodel->brushq3.num_triangles * 3);
out->num_vertices = 0;
out->num_triangles = 0;
- out->type = 0; // error
+ type = 0; // error
continue;
}
- switch(out->type)
+ switch(type)
{
case Q3FACETYPE_POLYGON:
case Q3FACETYPE_MESH:
// no processing necessary
- out->data_vertex3f = loadmodel->brushq3.data_vertex3f + out->firstvertex * 3;
- out->data_texcoordtexture2f = loadmodel->brushq3.data_texcoordtexture2f + out->firstvertex * 2;
- out->data_texcoordlightmap2f = loadmodel->brushq3.data_texcoordlightmap2f + out->firstvertex * 2;
- out->data_svector3f = loadmodel->brushq3.data_svector3f + out->firstvertex * 3;
- out->data_tvector3f = loadmodel->brushq3.data_tvector3f + out->firstvertex * 3;
- out->data_normal3f = loadmodel->brushq3.data_normal3f + out->firstvertex * 3;
- out->data_color4f = loadmodel->brushq3.data_color4f + out->firstvertex * 4;
- out->data_element3i = loadmodel->brushq3.data_element3i + out->firstelement;
- out->data_neighbor3i = loadmodel->brushq3.data_neighbor3i + out->firstelement;
+ out->data_vertex3f = loadmodel->brushq3.data_vertex3f + firstvertex * 3;
+ out->data_texcoordtexture2f = loadmodel->brushq3.data_texcoordtexture2f + firstvertex * 2;
+ out->data_texcoordlightmap2f = loadmodel->brushq3.data_texcoordlightmap2f + firstvertex * 2;
+ out->data_svector3f = loadmodel->brushq3.data_svector3f + firstvertex * 3;
+ out->data_tvector3f = loadmodel->brushq3.data_tvector3f + firstvertex * 3;
+ out->data_normal3f = loadmodel->brushq3.data_normal3f + firstvertex * 3;
+ out->data_color4f = loadmodel->brushq3.data_color4f + firstvertex * 4;
+ out->data_element3i = loadmodel->brushq3.data_element3i + firstelement;
+ out->data_neighbor3i = loadmodel->brushq3.data_neighbor3i + firstelement;
break;
case Q3FACETYPE_PATCH:
patchsize[0] = LittleLong(in->specific.patch.patchsize[0]);
patchsize[1] = LittleLong(in->specific.patch.patchsize[1]);
- if (patchsize[0] < 1 || patchsize[1] < 1)
+ if (patchsize[0] < 3 || patchsize[1] < 3 || !(patchsize[0] & 1) || !(patchsize[1] & 1) || patchsize[0] * patchsize[1] >= min(r_subdivisions_maxvertices.integer, r_subdivisions_collision_maxvertices.integer))
{
Con_Printf("Mod_Q3BSP_LoadFaces: face #%i (texture \"%s\"): invalid patchsize %ix%i\n", i, out->texture->name, patchsize[0], patchsize[1]);
out->num_vertices = 0;
out->num_triangles = 0;
- out->type = 0; // error
+ type = 0; // error
continue;
}
- originalvertex3f = loadmodel->brushq3.data_vertex3f + out->firstvertex * 3;
- //originalsvector3f = loadmodel->brushq3.data_svector3f + out->firstvertex * 3;
- //originaltvector3f = loadmodel->brushq3.data_tvector3f + out->firstvertex * 3;
- //originalnormal3f = loadmodel->brushq3.data_normal3f + out->firstvertex * 3;
- originaltexcoordtexture2f = loadmodel->brushq3.data_texcoordtexture2f + out->firstvertex * 2;
- originaltexcoordlightmap2f = loadmodel->brushq3.data_texcoordlightmap2f + out->firstvertex * 2;
- originalcolor4f = loadmodel->brushq3.data_color4f + out->firstvertex * 4;
- //originalelement3i = loadmodel->brushq3.data_element3i + out->firstelement;
- //originalneighbor3i = loadmodel->brushq3.data_neighbor3i + out->firstelement;
+ originalvertex3f = loadmodel->brushq3.data_vertex3f + firstvertex * 3;
+ //originalsvector3f = loadmodel->brushq3.data_svector3f + firstvertex * 3;
+ //originaltvector3f = loadmodel->brushq3.data_tvector3f + firstvertex * 3;
+ //originalnormal3f = loadmodel->brushq3.data_normal3f + firstvertex * 3;
+ originaltexcoordtexture2f = loadmodel->brushq3.data_texcoordtexture2f + firstvertex * 2;
+ originaltexcoordlightmap2f = loadmodel->brushq3.data_texcoordlightmap2f + firstvertex * 2;
+ originalcolor4f = loadmodel->brushq3.data_color4f + firstvertex * 4;
+ //originalelement3i = loadmodel->brushq3.data_element3i + firstelement;
+ //originalneighbor3i = loadmodel->brushq3.data_neighbor3i + firstelement;
/*
originalvertex3f = out->data_vertex3f;
//originalsvector3f = out->data_svector3f;
//originalneighbor3i = out->data_neighbor3i;
*/
// convert patch to Q3FACETYPE_MESH
- xlevel = QuadraticSplinePatchSubdivisionLevelOnX(patchsize[0], patchsize[1], 3, originalvertex3f, r_subdivisions_tolerance.value, 10);
- ylevel = QuadraticSplinePatchSubdivisionLevelOnY(patchsize[0], patchsize[1], 3, originalvertex3f, r_subdivisions_tolerance.value, 10);
+ xtess = Q3PatchTesselationOnX(patchsize[0], patchsize[1], 3, originalvertex3f, r_subdivisions_tolerance.value);
+ ytess = Q3PatchTesselationOnY(patchsize[0], patchsize[1], 3, originalvertex3f, r_subdivisions_tolerance.value);
// bound to user settings
- xlevel = bound(r_subdivisions_minlevel.integer, xlevel, r_subdivisions_maxlevel.integer);
- ylevel = bound(r_subdivisions_minlevel.integer, ylevel, r_subdivisions_maxlevel.integer);
+ xtess = bound(r_subdivisions_mintess.integer, xtess, r_subdivisions_maxtess.integer);
+ ytess = bound(r_subdivisions_mintess.integer, ytess, r_subdivisions_maxtess.integer);
// bound to sanity settings
- xlevel = bound(0, xlevel, 10);
- ylevel = bound(0, ylevel, 10);
+ xtess = bound(1, xtess, 1024);
+ ytess = bound(1, ytess, 1024);
// bound to user limit on vertices
- while ((xlevel > 0 || ylevel > 0) && (((patchsize[0] - 1) << xlevel) + 1) * (((patchsize[1] - 1) << ylevel) + 1) > min(r_subdivisions_maxvertices.integer, 262144))
+ while ((xtess > 1 || ytess > 1) && (((patchsize[0] - 1) * xtess) + 1) * (((patchsize[1] - 1) * ytess) + 1) > min(r_subdivisions_maxvertices.integer, 262144))
{
- if (xlevel > ylevel)
- xlevel--;
+ if (xtess > ytess)
+ xtess--;
else
- ylevel--;
+ ytess--;
}
- finalwidth = ((patchsize[0] - 1) << xlevel) + 1;
- finalheight = ((patchsize[1] - 1) << ylevel) + 1;
+ finalwidth = ((patchsize[0] - 1) * xtess) + 1;
+ finalheight = ((patchsize[1] - 1) * ytess) + 1;
finalvertices = finalwidth * finalheight;
finaltriangles = (finalwidth - 1) * (finalheight - 1) * 2;
out->data_vertex3f = Mem_Alloc(loadmodel->mempool, sizeof(float[20]) * finalvertices);
out->data_texcoordlightmap2f = out->data_texcoordtexture2f + finalvertices * 2;
out->data_element3i = Mem_Alloc(loadmodel->mempool, sizeof(int[6]) * finaltriangles);
out->data_neighbor3i = out->data_element3i + finaltriangles * 3;
- out->type = Q3FACETYPE_MESH;
- out->firstvertex = -1;
+ type = Q3FACETYPE_MESH;
+ firstvertex = -1;
out->num_vertices = finalvertices;
- out->firstelement = -1;
+ firstelement = -1;
out->num_triangles = finaltriangles;
// generate geometry
// (note: normals are skipped because they get recalculated)
- QuadraticSplinePatchSubdivideFloatBuffer(patchsize[0], patchsize[1], xlevel, ylevel, 3, originalvertex3f, out->data_vertex3f);
- QuadraticSplinePatchSubdivideFloatBuffer(patchsize[0], patchsize[1], xlevel, ylevel, 2, originaltexcoordtexture2f, out->data_texcoordtexture2f);
- QuadraticSplinePatchSubdivideFloatBuffer(patchsize[0], patchsize[1], xlevel, ylevel, 2, originaltexcoordlightmap2f, out->data_texcoordlightmap2f);
- QuadraticSplinePatchSubdivideFloatBuffer(patchsize[0], patchsize[1], xlevel, ylevel, 4, originalcolor4f, out->data_color4f);
- // generate elements
- e = out->data_element3i;
- for (y = 0;y < finalheight - 1;y++)
- {
- row0 = (y + 0) * finalwidth;
- row1 = (y + 1) * finalwidth;
- for (x = 0;x < finalwidth - 1;x++)
- {
- *e++ = row0;
- *e++ = row1;
- *e++ = row0 + 1;
- *e++ = row1;
- *e++ = row1 + 1;
- *e++ = row0 + 1;
- row0++;
- row1++;
- }
- }
- out->num_triangles = Mod_RemoveDegenerateTriangles(out->num_triangles, out->data_element3i, out->data_element3i, out->data_vertex3f);
- if (developer.integer)
+ Q3PatchTesselateFloat(3, sizeof(float[3]), out->data_vertex3f, patchsize[0], patchsize[1], sizeof(float[3]), originalvertex3f, xtess, ytess);
+ Q3PatchTesselateFloat(2, sizeof(float[2]), out->data_texcoordtexture2f, patchsize[0], patchsize[1], sizeof(float[2]), originaltexcoordtexture2f, xtess, ytess);
+ Q3PatchTesselateFloat(2, sizeof(float[2]), out->data_texcoordlightmap2f, patchsize[0], patchsize[1], sizeof(float[2]), originaltexcoordlightmap2f, xtess, ytess);
+ Q3PatchTesselateFloat(4, sizeof(float[4]), out->data_color4f, patchsize[0], patchsize[1], sizeof(float[4]), originalcolor4f, xtess, ytess);
+ Q3PatchTriangleElements(out->data_element3i, finalwidth, finalheight);
+ if (developer.integer >= 2)
{
if (out->num_triangles < finaltriangles)
Con_Printf("Mod_Q3BSP_LoadFaces: %ix%i curve subdivided to %i vertices / %i triangles, %i degenerate triangles removed (leaving %i)\n", patchsize[0], patchsize[1], out->num_vertices, finaltriangles, finaltriangles - out->num_triangles, out->num_triangles);
}
// q3map does not put in collision brushes for curves... ugh
// build the lower quality collision geometry
- out->collisions = true;
- xlevel = QuadraticSplinePatchSubdivisionLevelOnX(patchsize[0], patchsize[1], 3, originalvertex3f, r_subdivisions_collision_tolerance.value, 10);
- ylevel = QuadraticSplinePatchSubdivisionLevelOnY(patchsize[0], patchsize[1], 3, originalvertex3f, r_subdivisions_collision_tolerance.value, 10);
+ xtess = Q3PatchTesselationOnX(patchsize[0], patchsize[1], 3, originalvertex3f, r_subdivisions_collision_tolerance.value);
+ ytess = Q3PatchTesselationOnY(patchsize[0], patchsize[1], 3, originalvertex3f, r_subdivisions_collision_tolerance.value);
// bound to user settings
- xlevel = bound(r_subdivisions_collision_minlevel.integer, xlevel, r_subdivisions_collision_maxlevel.integer);
- ylevel = bound(r_subdivisions_collision_minlevel.integer, ylevel, r_subdivisions_collision_maxlevel.integer);
+ xtess = bound(r_subdivisions_collision_mintess.integer, xtess, r_subdivisions_collision_maxtess.integer);
+ ytess = bound(r_subdivisions_collision_mintess.integer, ytess, r_subdivisions_collision_maxtess.integer);
// bound to sanity settings
- xlevel = bound(0, xlevel, 10);
- ylevel = bound(0, ylevel, 10);
+ xtess = bound(1, xtess, 1024);
+ ytess = bound(1, ytess, 1024);
// bound to user limit on vertices
- while ((xlevel > 0 || ylevel > 0) && (((patchsize[0] - 1) << xlevel) + 1) * (((patchsize[1] - 1) << ylevel) + 1) > min(r_subdivisions_collision_maxvertices.integer, 262144))
+ while ((xtess > 1 || ytess > 1) && (((patchsize[0] - 1) * xtess) + 1) * (((patchsize[1] - 1) * ytess) + 1) > min(r_subdivisions_collision_maxvertices.integer, 262144))
{
- if (xlevel > ylevel)
- xlevel--;
+ if (xtess > ytess)
+ xtess--;
else
- ylevel--;
+ ytess--;
}
- finalwidth = ((patchsize[0] - 1) << xlevel) + 1;
- finalheight = ((patchsize[1] - 1) << ylevel) + 1;
+ finalwidth = ((patchsize[0] - 1) * xtess) + 1;
+ finalheight = ((patchsize[1] - 1) * ytess) + 1;
finalvertices = finalwidth * finalheight;
finaltriangles = (finalwidth - 1) * (finalheight - 1) * 2;
+
out->data_collisionvertex3f = Mem_Alloc(loadmodel->mempool, sizeof(float[3]) * finalvertices);
out->data_collisionelement3i = Mem_Alloc(loadmodel->mempool, sizeof(int[3]) * finaltriangles);
out->num_collisionvertices = finalvertices;
out->num_collisiontriangles = finaltriangles;
- QuadraticSplinePatchSubdivideFloatBuffer(patchsize[0], patchsize[1], xlevel, ylevel, 3, originalvertex3f, out->data_collisionvertex3f);
- // generate elements
- e = out->data_collisionelement3i;
- for (y = 0;y < finalheight - 1;y++)
- {
- row0 = (y + 0) * finalwidth;
- row1 = (y + 1) * finalwidth;
- for (x = 0;x < finalwidth - 1;x++)
- {
- *e++ = row0;
- *e++ = row1;
- *e++ = row0 + 1;
- *e++ = row1;
- *e++ = row1 + 1;
- *e++ = row0 + 1;
- row0++;
- row1++;
- }
- }
+ Q3PatchTesselateFloat(3, sizeof(float[3]), out->data_collisionvertex3f, patchsize[0], patchsize[1], sizeof(float[3]), originalvertex3f, xtess, ytess);
+ Q3PatchTriangleElements(out->data_collisionelement3i, finalwidth, finalheight);
+
+ Mod_SnapVertices(3, out->num_vertices, out->data_vertex3f, 0.25);
+ Mod_SnapVertices(3, out->num_collisionvertices, out->data_collisionvertex3f, 1);
+
+ oldnumtriangles = out->num_triangles;
+ oldnumtriangles2 = out->num_collisiontriangles;
+ out->num_triangles = Mod_RemoveDegenerateTriangles(out->num_triangles, out->data_element3i, out->data_element3i, out->data_vertex3f);
out->num_collisiontriangles = Mod_RemoveDegenerateTriangles(out->num_collisiontriangles, out->data_collisionelement3i, out->data_collisionelement3i, out->data_collisionvertex3f);
if (developer.integer)
- {
- if (out->num_collisiontriangles < finaltriangles)
- Con_Printf("Mod_Q3BSP_LoadFaces: %ix%i curve subdivided for collisions to %i vertices / %i triangles, %i degenerate triangles removed (leaving %i)\n", patchsize[0], patchsize[1], out->num_collisionvertices, finaltriangles, finaltriangles - out->num_collisiontriangles, out->num_collisiontriangles);
- else
- Con_Printf("Mod_Q3BSP_LoadFaces: %ix%i curve subdivided for collisions to %i vertices / %i triangles\n", patchsize[0], patchsize[1], out->num_collisionvertices, out->num_collisiontriangles);
- }
+ Con_Printf("Mod_Q3BSP_LoadFaces: %ix%i curve became %i:%i vertices / %i:%i triangles (%i:%i degenerate)\n", patchsize[0], patchsize[1], out->num_vertices, out->num_collisionvertices, oldnumtriangles, oldnumtriangles2, oldnumtriangles - out->num_triangles, oldnumtriangles2 - out->num_collisiontriangles);
break;
case Q3FACETYPE_FLARE:
- Con_DPrintf("Mod_Q3BSP_LoadFaces: face #%i (texture \"%s\"): Q3FACETYPE_FLARE not supported (yet)\n", i, out->texture->name);
+ if (developer.integer >= 2)
+ Con_Printf("Mod_Q3BSP_LoadFaces: face #%i (texture \"%s\"): Q3FACETYPE_FLARE not supported (yet)\n", i, out->texture->name);
// don't render it
out->num_vertices = 0;
out->num_triangles = 0;
- out->type = 0;
+ type = 0;
break;
}
for (j = 0, invalidelements = 0;j < out->num_triangles * 3;j++)
invalidelements++;
if (invalidelements)
{
- Con_Printf("Mod_Q3BSP_LoadFaces: Warning: face #%i has %i invalid elements, type = %i, texture->name = \"%s\", texture->surfaceflags = %i, texture->nativecontents = %i, firstvertex = %i, numvertices = %i, firstelement = %i, numelements = %i, elements list:\n", i, invalidelements, out->type, out->texture->name, out->texture->surfaceflags, out->texture->nativecontents, out->firstvertex, out->num_vertices, out->firstelement, out->num_triangles * 3);
+ Con_Printf("Mod_Q3BSP_LoadFaces: Warning: face #%i has %i invalid elements, type = %i, texture->name = \"%s\", texture->surfaceflags = %i, texture->nativecontents = %i, firstvertex = %i, numvertices = %i, firstelement = %i, numelements = %i, elements list:\n", i, invalidelements, type, out->texture->name, out->texture->surfaceflags, out->texture->nativecontents, firstvertex, out->num_vertices, firstelement, out->num_triangles * 3);
for (j = 0;j < out->num_triangles * 3;j++)
{
Con_Printf(" %i", out->data_element3i[j]);
static void Mod_Q3BSP_LoadLeafFaces(lump_t *l)
{
int *in;
- q3mface_t **out;
+ q3msurface_t **out;
int i, n, count;
in = (void *)(mod_base + l->fileofs);
loadmodel->brushq3.data_leaffaces = out;
loadmodel->brushq3.num_leaffaces = count;
+ loadmodel->brushq3.data_leaffacenums = Mem_Alloc(loadmodel->mempool, count * sizeof(int));
+
for (i = 0;i < count;i++, in++, out++)
{
n = LittleLong(*in);
if (n < 0 || n >= loadmodel->brushq3.num_faces)
Host_Error("Mod_Q3BSP_LoadLeafFaces: invalid face index %i (%i faces)\n", n, loadmodel->brushq3.num_faces);
*out = loadmodel->brushq3.data_faces + n;
+ loadmodel->brushq3.data_leaffacenums[i] = n;
}
}
if (n < 0 || n + c > loadmodel->brushq3.num_leaffaces)
Host_Error("Mod_Q3BSP_LoadLeafs: invalid leafface range %i : %i (%i leaffaces)\n", n, n + c, loadmodel->brushq3.num_leaffaces);
out->firstleafface = loadmodel->brushq3.data_leaffaces + n;
+ out->firstleaffacenum = loadmodel->brushq3.data_leaffacenums + n;
out->numleaffaces = c;
n = LittleLong(in->firstleafbrush);
c = LittleLong(in->numleafbrushes);
// leafs to find real number of clusters
loadmodel->brush.num_pvsclusters = 1;
for (i = 0;i < loadmodel->brushq3.num_leafs;i++)
- loadmodel->brush.num_pvsclusters = min(loadmodel->brush.num_pvsclusters, loadmodel->brushq3.data_leafs[i].clusterindex + 1);
+ loadmodel->brush.num_pvsclusters = max(loadmodel->brush.num_pvsclusters, loadmodel->brushq3.data_leafs[i].clusterindex + 1);
// create clusters
loadmodel->brush.num_pvsclusterbytes = (loadmodel->brush.num_pvsclusters + 7) / 8;
int i, startside, endside;
float dist1, dist2, midfrac, mid[3], nodesegmentmins[3], nodesegmentmaxs[3];
q3mleaf_t *leaf;
- q3mface_t *face;
+ q3msurface_t *face;
colbrushf_t *brush;
if (startfrac > trace->realfraction)
return;
for (i = 0;i < leaf->numleaffaces;i++)
{
face = leaf->firstleafface[i];
- if (face->collisions && face->collisionmarkframe != markframe && BoxesOverlap(nodesegmentmins, nodesegmentmaxs, face->mins, face->maxs))
+ if (face->num_collisiontriangles && face->collisionmarkframe != markframe && BoxesOverlap(nodesegmentmins, nodesegmentmaxs, face->mins, face->maxs))
{
face->collisionmarkframe = markframe;
Collision_TraceLineTriangleMeshFloat(trace, linestart, lineend, face->num_collisiontriangles, face->data_collisionelement3i, face->data_collisionvertex3f, face->texture->supercontents, segmentmins, segmentmaxs);
float nodesegmentmins[3], nodesegmentmaxs[3];
q3mleaf_t *leaf;
colbrushf_t *brush;
- q3mface_t *face;
+ q3msurface_t *face;
/*
// find which nodes the line is in and recurse for them
while (node->plane)
for (i = 0;i < leaf->numleaffaces;i++)
{
face = leaf->firstleafface[i];
- if (face->collisions && face->markframe != markframe && BoxesOverlap(nodesegmentmins, nodesegmentmaxs, face->mins, face->maxs))
+ if (face->num_collisiontriangles && face->collisionmarkframe != markframe && BoxesOverlap(nodesegmentmins, nodesegmentmaxs, face->mins, face->maxs))
{
- face->markframe = markframe;
+ face->collisionmarkframe = markframe;
Collision_TraceBrushTriangleMeshFloat(trace, thisbrush_start, thisbrush_end, face->num_collisiontriangles, face->data_collisionelement3i, face->data_collisionvertex3f, face->texture->supercontents, segmentmins, segmentmaxs);
}
}
colbrushf_t *thisbrush_start, *thisbrush_end;
matrix4x4_t startmatrix, endmatrix;
static int markframe = 0;
- q3mface_t *face;
+ q3msurface_t *face;
memset(trace, 0, sizeof(*trace));
trace->fraction = 1;
trace->realfraction = 1;
for (i = 0;i < model->brushq3.data_thismodel->numfaces;i++)
{
face = model->brushq3.data_thismodel->firstface + i;
- if (face->collisions)
+ if (face->num_collisiontriangles)
Collision_TraceLineTriangleMeshFloat(trace, boxstartmins, boxendmins, face->num_collisiontriangles, face->data_collisionelement3i, face->data_collisionvertex3f, face->texture->supercontents, segmentmins, segmentmaxs);
}
}
for (i = 0;i < model->brushq3.data_thismodel->numfaces;i++)
{
face = model->brushq3.data_thismodel->firstface + i;
- if (face->collisions)
+ if (face->num_collisiontriangles)
Collision_TraceBrushTriangleMeshFloat(trace, thisbrush_start, thisbrush_end, face->num_collisiontriangles, face->data_collisionelement3i, face->data_collisionvertex3f, face->texture->supercontents, segmentmins, segmentmaxs);
}
}
else
{
// box crosses plane, take one path and remember the other
- nodestack[nodestackindex++] = node->children[0];
+ if (nodestackindex < 1024)
+ nodestack[nodestackindex++] = node->children[0];
node = node->children[1];
}
}
if ((pvs == NULL || CHECKPVSBIT(pvs, leaf->clusterindex)))
{
int marksurfacenum;
- q3mface_t *surf;
+ q3msurface_t *surf;
if (maxleafs && *numleafs < maxleafs)
leaflist[(*numleaf)++] = leaf;
if (maxsurfaces)
}
*/
+void Mod_Q3BSP_BuildTextureFaceLists(void)
+{
+ int i, j;
+ loadmodel->brushq3.data_texturefaces = Mem_Alloc(loadmodel->mempool, loadmodel->nummodelsurfaces * sizeof(q3msurface_t *));
+ loadmodel->brushq3.data_texturefacenums = Mem_Alloc(loadmodel->mempool, loadmodel->nummodelsurfaces * sizeof(int));
+ for (i = 0;i < loadmodel->brushq3.num_textures;i++)
+ loadmodel->brushq3.data_textures[i].numfaces = 0;
+ for (i = 0;i < loadmodel->nummodelsurfaces;i++)
+ loadmodel->brushq3.data_faces[loadmodel->surfacelist[i]].texture->numfaces++;
+ j = 0;
+ for (i = 0;i < loadmodel->brushq3.num_textures;i++)
+ {
+ loadmodel->brushq3.data_textures[i].facelist = loadmodel->brushq3.data_texturefaces + j;
+ loadmodel->brushq3.data_textures[i].facenumlist = loadmodel->brushq3.data_texturefacenums + j;
+ j += loadmodel->brushq3.data_textures[i].numfaces;
+ loadmodel->brushq3.data_textures[i].numfaces = 0;
+ }
+ for (i = 0;i < loadmodel->nummodelsurfaces;i++)
+ {
+ loadmodel->brushq3.data_faces[loadmodel->surfacelist[i]].texture->facenumlist[loadmodel->brushq3.data_faces[loadmodel->surfacelist[i]].texture->numfaces] = loadmodel->surfacelist[i];
+ loadmodel->brushq3.data_faces[loadmodel->surfacelist[i]].texture->facelist[loadmodel->brushq3.data_faces[loadmodel->surfacelist[i]].texture->numfaces++] = loadmodel->brushq3.data_faces + loadmodel->surfacelist[i];
+ }
+}
+
+void Mod_Q3BSP_RecursiveFindNumLeafs(q3mnode_t *node)
+{
+ int numleafs;
+ while (node->plane)
+ {
+ Mod_Q3BSP_RecursiveFindNumLeafs(node->children[0]);
+ node = node->children[1];
+ }
+ numleafs = ((q3mleaf_t *)node - loadmodel->brushq3.data_leafs) + 1;
+ if (loadmodel->brushq3.num_leafs < numleafs)
+ loadmodel->brushq3.num_leafs = numleafs;
+}
+
extern void R_Q3BSP_DrawSky(struct entity_render_s *ent);
extern void R_Q3BSP_Draw(struct entity_render_s *ent);
extern void R_Q3BSP_GetLightInfo(entity_render_t *ent, vec3_t relativelightorigin, float lightradius, vec3_t outmins, vec3_t outmaxs, int *outclusterlist, qbyte *outclusterpvs, int *outnumclusterspointer, int *outsurfacelist, qbyte *outsurfacepvs, int *outnumsurfacespointer);
extern void R_Q3BSP_DrawShadowVolume(entity_render_t *ent, vec3_t relativelightorigin, float lightradius, int numsurfaces, const int *surfacelist);
-extern void R_Q3BSP_DrawLight(entity_render_t *ent, vec3_t relativelightorigin, vec3_t relativeeyeorigin, float lightradius, float *lightcolor, const matrix4x4_t *matrix_modeltolight, const matrix4x4_t *matrix_modeltoattenuationxyz, const matrix4x4_t *matrix_modeltoattenuationz, rtexture_t *lightcubemap, int numsurfaces, const int *surfacelist);
+extern void R_Q3BSP_DrawLight(entity_render_t *ent, vec3_t relativelightorigin, vec3_t relativeeyeorigin, float lightradius, float *lightcolor, const matrix4x4_t *matrix_modeltolight, const matrix4x4_t *matrix_modeltoattenuationxyz, const matrix4x4_t *matrix_modeltoattenuationz, rtexture_t *lightcubemap, vec_t ambientscale, vec_t diffusescale, vec_t specularscale, int numsurfaces, const int *surfacelist);
void Mod_Q3BSP_Load(model_t *mod, void *buffer)
{
int i, j, numshadowmeshtriangles;
q3dheader_t *header;
float corner[3], yawradius, modelradius;
- q3mface_t *face;
+ q3msurface_t *face;
mod->type = mod_brushq3;
- mod->numframes = 1;
+ mod->numframes = 2; // although alternate textures are not supported it is annoying to complain about no such frame 1
mod->numskins = 1;
header = (q3dheader_t *)buffer;
if (i != Q3BSPVERSION)
Host_Error("Mod_Q3BSP_Load: %s has wrong version number (%i, should be %i)", mod->name, i, Q3BSPVERSION);
if (mod->isworldmodel)
- {
Cvar_SetValue("halflifebsp", false);
- // until we get a texture for it...
- R_ResetQuakeSky();
- }
mod->soundfromcenter = true;
mod->TraceBox = Mod_Q3BSP_TraceBox;
mod_base = (qbyte *)header;
// swap all the lumps
- for (i = 0;i < (int) sizeof(*header) / 4;i++)
- ((int *)header)[i] = LittleLong(((int *)header)[i]);
+ header->ident = LittleLong(header->ident);
+ header->version = LittleLong(header->version);
+ for (i = 0;i < Q3HEADER_LUMPS;i++)
+ {
+ header->lumps[i].fileofs = LittleLong(header->lumps[i].fileofs);
+ header->lumps[i].filelen = LittleLong(header->lumps[i].filelen);
+ }
Mod_Q3BSP_LoadEntities(&header->lumps[Q3LUMP_ENTITIES]);
Mod_Q3BSP_LoadTextures(&header->lumps[Q3LUMP_TEXTURES]);
Mod_ShadowMesh_AddMesh(loadmodel->mempool, loadmodel->brush.shadowmesh, NULL, NULL, NULL, face->data_vertex3f, NULL, NULL, NULL, NULL, face->num_triangles, face->data_element3i);
loadmodel->brush.shadowmesh = Mod_ShadowMesh_Finish(loadmodel->mempool, loadmodel->brush.shadowmesh, false, true);
Mod_BuildTriangleNeighbors(loadmodel->brush.shadowmesh->neighbor3i, loadmodel->brush.shadowmesh->element3i, loadmodel->brush.shadowmesh->numtriangles);
-
+
+ loadmodel->brushq3.num_leafs = 0;
+ Mod_Q3BSP_RecursiveFindNumLeafs(loadmodel->brushq3.data_nodes);
+
+ mod = loadmodel;
for (i = 0;i < loadmodel->brushq3.num_models;i++)
{
- if (i == 0)
- mod = loadmodel;
- else
+ if (i > 0)
{
char name[10];
// LordHavoc: only register submodels if it is the world
- // (prevents bsp models from replacing world submodels)
+ // (prevents external bsp models from replacing world submodels with
+ // their own)
if (!loadmodel->isworldmodel)
continue;
// duplicate the basic information
mod->brushq3.submodel = i;
// make the model surface list (used by shadowing/lighting)
- mod->numsurfaces = mod->brushq3.data_thismodel->numfaces;
- mod->surfacelist = Mem_Alloc(loadmodel->mempool, mod->numsurfaces * sizeof(*mod->surfacelist));
- for (j = 0;j < mod->numsurfaces;j++)
+ mod->nummodelsurfaces = mod->brushq3.data_thismodel->numfaces;
+ mod->surfacelist = Mem_Alloc(loadmodel->mempool, mod->nummodelsurfaces * sizeof(*mod->surfacelist));
+ for (j = 0;j < mod->nummodelsurfaces;j++)
mod->surfacelist[j] = (mod->brushq3.data_thismodel->firstface - mod->brushq3.data_faces) + j;
VectorCopy(mod->brushq3.data_thismodel->mins, mod->normalmins);
if (j < mod->brushq3.data_thismodel->numfaces)
mod->DrawSky = R_Q3BSP_DrawSky;
}
+
+ Mod_Q3BSP_BuildTextureFaceLists();
}
void Mod_IBSP_Load(model_t *mod, void *buffer)