X-Git-Url: http://de.git.xonotic.org/?p=xonotic%2Fdarkplaces.git;a=blobdiff_plain;f=model_brush.c;h=024f2a85c8c33219a6cb6ec40dcd91a0410af750;hp=22d60f4e7e7328f5cb68c1190b01a71319bc6354;hb=6e48dafd2f198e53ef8031379080656e9483e709;hpb=457882d8ab1fa2a9c8964d1cf3e3efbefac085ae diff --git a/model_brush.c b/model_brush.c index 22d60f4e..024f2a85 100644 --- a/model_brush.c +++ b/model_brush.c @@ -28,9 +28,8 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. //cvar_t r_subdivide_size = {CVAR_SAVE, "r_subdivide_size", "128", "how large water polygons should be (smaller values produce more polygons which give better warping effects)"}; cvar_t halflifebsp = {0, "halflifebsp", "0", "indicates the current map is hlbsp format (useful to know because of different bounding box sizes)"}; -cvar_t mcbsp = {0, "mcbsp", "0", "indicates the current map is mcbsp format (useful to know because of different bounding box sizes)"}; cvar_t r_novis = {0, "r_novis", "0", "draws whole level, see also sv_cullentities_pvs 0"}; -cvar_t r_lightmaprgba = {0, "r_lightmaprgba", "1", "whether to use RGBA (32bit) or RGB (24bit) lightmaps"}; +cvar_t r_picmipworld = {CVAR_SAVE, "r_picmipworld", "1", "whether gl_picmip shall apply to world textures too"}; cvar_t r_nosurftextures = {0, "r_nosurftextures", "0", "pretends there was no texture lump found in the q1bsp/hlbsp loading (useful for debugging this rare case)"}; cvar_t r_subdivisions_tolerance = {0, "r_subdivisions_tolerance", "4", "maximum error tolerance on curve subdivision for rendering purposes (in other words, the curves will be given as many polygons as necessary to represent curves at this quality)"}; cvar_t r_subdivisions_mintess = {0, "r_subdivisions_mintess", "1", "minimum number of subdivisions (values above 1 will smooth curves that don't need it)"}; @@ -43,7 +42,7 @@ cvar_t r_subdivisions_collision_maxvertices = {0, "r_subdivisions_collision_maxv cvar_t mod_q3bsp_curves_collisions = {0, "mod_q3bsp_curves_collisions", "1", "enables collisions with curves (SLOW)"}; cvar_t mod_q3bsp_optimizedtraceline = {0, "mod_q3bsp_optimizedtraceline", "1", "whether to use optimized traceline code for line traces (as opposed to tracebox code)"}; cvar_t mod_q3bsp_debugtracebrush = {0, "mod_q3bsp_debugtracebrush", "0", "selects different tracebrush bsp recursion algorithms (for debugging purposes only)"}; -cvar_t mod_q3bsp_lightmapmergepower = {CVAR_SAVE, "mod_q3bsp_lightmapmergepower", "5", "merges the quake3 128x128 lightmap textures into larger lightmap group textures to speed up rendering, 1 = 256x256, 2 = 512x512, 3 = 1024x1024, 4 = 2048x2048, 5 = 4096x4096, ..."}; +cvar_t mod_q3bsp_lightmapmergepower = {CVAR_SAVE, "mod_q3bsp_lightmapmergepower", "4", "merges the quake3 128x128 lightmap textures into larger lightmap group textures to speed up rendering, 1 = 256x256, 2 = 512x512, 3 = 1024x1024, 4 = 2048x2048, 5 = 4096x4096, ..."}; static texture_t mod_q1bsp_texture_solid; static texture_t mod_q1bsp_texture_sky; @@ -55,9 +54,8 @@ void Mod_BrushInit(void) { // Cvar_RegisterVariable(&r_subdivide_size); Cvar_RegisterVariable(&halflifebsp); - Cvar_RegisterVariable(&mcbsp); Cvar_RegisterVariable(&r_novis); - Cvar_RegisterVariable(&r_lightmaprgba); + Cvar_RegisterVariable(&r_picmipworld); Cvar_RegisterVariable(&r_nosurftextures); Cvar_RegisterVariable(&r_subdivisions_tolerance); Cvar_RegisterVariable(&r_subdivisions_mintess); @@ -98,7 +96,7 @@ void Mod_BrushInit(void) mod_q1bsp_texture_water.supercontents = SUPERCONTENTS_WATER; } -static mleaf_t *Mod_Q1BSP_PointInLeaf(model_t *model, const vec3_t p) +static mleaf_t *Mod_Q1BSP_PointInLeaf(dp_model_t *model, const vec3_t p) { mnode_t *node; @@ -114,7 +112,7 @@ static mleaf_t *Mod_Q1BSP_PointInLeaf(model_t *model, const vec3_t p) return (mleaf_t *)node; } -static void Mod_Q1BSP_AmbientSoundLevelsForPoint(model_t *model, const vec3_t p, unsigned char *out, int outsize) +static void Mod_Q1BSP_AmbientSoundLevelsForPoint(dp_model_t *model, const vec3_t p, unsigned char *out, int outsize) { int i; mleaf_t *leaf; @@ -133,7 +131,7 @@ static void Mod_Q1BSP_AmbientSoundLevelsForPoint(model_t *model, const vec3_t p, memset(out, 0, outsize); } -static int Mod_Q1BSP_FindBoxClusters(model_t *model, const vec3_t mins, const vec3_t maxs, int maxclusters, int *clusterlist) +static int Mod_Q1BSP_FindBoxClusters(dp_model_t *model, const vec3_t mins, const vec3_t maxs, int maxclusters, int *clusterlist) { int numclusters = 0; int nodestackindex = 0; @@ -199,7 +197,7 @@ static int Mod_Q1BSP_FindBoxClusters(model_t *model, const vec3_t mins, const ve return numclusters; } -static int Mod_Q1BSP_BoxTouchingPVS(model_t *model, const unsigned char *pvs, const vec3_t mins, const vec3_t maxs) +static int Mod_Q1BSP_BoxTouchingPVS(dp_model_t *model, const unsigned char *pvs, const vec3_t mins, const vec3_t maxs) { int nodestackindex = 0; mnode_t *node, *nodestack[1024]; @@ -270,7 +268,7 @@ static int Mod_Q1BSP_BoxTouchingPVS(model_t *model, const unsigned char *pvs, co return false; } -static int Mod_Q1BSP_BoxTouchingLeafPVS(model_t *model, const unsigned char *pvs, const vec3_t mins, const vec3_t maxs) +static int Mod_Q1BSP_BoxTouchingLeafPVS(dp_model_t *model, const unsigned char *pvs, const vec3_t mins, const vec3_t maxs) { int nodestackindex = 0; mnode_t *node, *nodestack[1024]; @@ -341,7 +339,7 @@ static int Mod_Q1BSP_BoxTouchingLeafPVS(model_t *model, const unsigned char *pvs return false; } -static int Mod_Q1BSP_BoxTouchingVisibleLeafs(model_t *model, const unsigned char *visibleleafs, const vec3_t mins, const vec3_t maxs) +static int Mod_Q1BSP_BoxTouchingVisibleLeafs(dp_model_t *model, const unsigned char *visibleleafs, const vec3_t mins, const vec3_t maxs) { int nodestackindex = 0; mnode_t *node, *nodestack[1024]; @@ -416,7 +414,7 @@ typedef struct findnonsolidlocationinfo_s vec_t radius; vec3_t nudge; vec_t bestdist; - model_t *model; + dp_model_t *model; } findnonsolidlocationinfo_t; @@ -535,7 +533,7 @@ static void Mod_Q1BSP_FindNonSolidLocation_r(findnonsolidlocationinfo_t *info, m } } -static void Mod_Q1BSP_FindNonSolidLocation(model_t *model, const vec3_t in, vec3_t out, float radius) +static void Mod_Q1BSP_FindNonSolidLocation(dp_model_t *model, const vec3_t in, vec3_t out, float radius) { int i; findnonsolidlocationinfo_t info; @@ -559,7 +557,7 @@ static void Mod_Q1BSP_FindNonSolidLocation(model_t *model, const vec3_t in, vec3 VectorCopy(info.center, out); } -int Mod_Q1BSP_SuperContentsFromNativeContents(model_t *model, int nativecontents) +int Mod_Q1BSP_SuperContentsFromNativeContents(dp_model_t *model, int nativecontents) { switch(nativecontents) { @@ -579,7 +577,7 @@ int Mod_Q1BSP_SuperContentsFromNativeContents(model_t *model, int nativecontents return 0; } -int Mod_Q1BSP_NativeContentsFromSuperContents(model_t *model, int supercontents) +int Mod_Q1BSP_NativeContentsFromSuperContents(dp_model_t *model, int supercontents) { if (supercontents & (SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY)) return CONTENTS_SOLID; @@ -627,7 +625,7 @@ static int Mod_Q1BSP_RecursiveHullCheck(RecursiveHullCheckTraceInfo_t *t, int nu double t1, t2; // variables that need to be stored on the stack when recursing - dclipnode_t *node; + mclipnode_t *node; int side; double midf, mid[3]; @@ -783,8 +781,16 @@ loc0: //#if COLLISIONPARANOID < 2 static int Mod_Q1BSP_RecursiveHullCheckPoint(RecursiveHullCheckTraceInfo_t *t, int num) { + mplane_t *plane; + mclipnode_t *nodes = t->hull->clipnodes; + mplane_t *planes = t->hull->planes; + vec3_t point; + VectorCopy(t->start, point); while (num >= 0) - num = t->hull->clipnodes[num].children[(t->hull->planes[t->hull->clipnodes[num].planenum].type < 3 ? t->start[t->hull->planes[t->hull->clipnodes[num].planenum].type] : DotProduct(t->hull->planes[t->hull->clipnodes[num].planenum].normal, t->start)) < t->hull->planes[t->hull->clipnodes[num].planenum].dist]; + { + plane = planes + nodes[num].planenum; + num = nodes[num].children[(plane->type < 3 ? point[plane->type] : DotProduct(plane->normal, point)) < plane->dist]; + } num = Mod_Q1BSP_SuperContentsFromNativeContents(NULL, num); t->trace->startsupercontents |= num; if (num & SUPERCONTENTS_LIQUIDSMASK) @@ -820,13 +826,6 @@ static void Mod_Q1BSP_TraceBox(struct model_s *model, int frame, trace_t *trace, VectorSubtract(boxmaxs, boxmins, boxsize); if (boxsize[0] < 3) rhc.hull = &model->brushq1.hulls[0]; // 0x0x0 - else if (model->brush.ismcbsp) - { - if (boxsize[2] < 48) // pick the nearest of 40 or 56 - rhc.hull = &model->brushq1.hulls[2]; // 16x16x40 - else - rhc.hull = &model->brushq1.hulls[1]; // 16x16x56 - } else if (model->brush.ishlbsp) { // LordHavoc: this has to have a minor tolerance (the .1) because of @@ -884,6 +883,20 @@ static void Mod_Q1BSP_TraceBox(struct model_s *model, int frame, trace_t *trace, #endif } +static int Mod_Q1BSP_PointSuperContents(struct model_s *model, int frame, const vec3_t point) +{ + int num = model->brushq1.hulls[0].firstclipnode; + mplane_t *plane; + mclipnode_t *nodes = model->brushq1.hulls[0].clipnodes; + mplane_t *planes = model->brushq1.hulls[0].planes; + while (num >= 0) + { + plane = planes + nodes[num].planenum; + num = nodes[num].children[(plane->type < 3 ? point[plane->type] : DotProduct(plane->normal, point)) < plane->dist]; + } + return Mod_Q1BSP_SuperContentsFromNativeContents(NULL, num); +} + void Collision_ClipTrace_Box(trace_t *trace, const vec3_t cmins, const vec3_t cmaxs, const vec3_t start, const vec3_t mins, const vec3_t maxs, const vec3_t end, int hitsupercontentsmask, int boxsupercontents, int boxq3surfaceflags, texture_t *boxtexture) { #if 1 @@ -923,7 +936,7 @@ void Collision_ClipTrace_Box(trace_t *trace, const vec3_t cmins, const vec3_t cm #else RecursiveHullCheckTraceInfo_t rhc; static hull_t box_hull; - static dclipnode_t box_clipnodes[6]; + static mclipnode_t box_clipnodes[6]; static mplane_t box_planes[6]; // fill in a default trace memset(&rhc, 0, sizeof(rhc)); @@ -1058,7 +1071,7 @@ static qboolean Mod_Q1BSP_TraceLineOfSight(struct model_s *model, const vec3_t s return Mod_Q1BSP_TraceLineOfSight_RecursiveNodeCheck(model->brush.data_nodes, tracestart, traceend) != 2; } -static int Mod_Q1BSP_LightPoint_RecursiveBSPNode(model_t *model, vec3_t ambientcolor, vec3_t diffusecolor, vec3_t diffusenormal, const mnode_t *node, float x, float y, float startz, float endz) +static int Mod_Q1BSP_LightPoint_RecursiveBSPNode(dp_model_t *model, vec3_t ambientcolor, vec3_t diffusecolor, vec3_t diffusenormal, const mnode_t *node, float x, float y, float startz, float endz) { int side; float front, back; @@ -1109,8 +1122,14 @@ loc0: // check for impact on this node if (node->numsurfaces) { - int i, ds, dt; + int i, dsi, dti, lmwidth, lmheight; + float ds, dt; msurface_t *surface; + unsigned char *lightmap; + int maps, line3, size3; + float dsfrac; + float dtfrac; + float scale, w, w00, w01, w10, w11; surface = model->data_surfaces + node->firstsurface; for (i = 0;i < node->numsurfaces;i++, surface++) @@ -1118,66 +1137,46 @@ loc0: if (!(surface->texture->basematerialflags & MATERIALFLAG_WALL) || !surface->lightmapinfo->samples) continue; // no lightmaps - ds = (int) (x * surface->lightmapinfo->texinfo->vecs[0][0] + y * surface->lightmapinfo->texinfo->vecs[0][1] + mid * surface->lightmapinfo->texinfo->vecs[0][2] + surface->lightmapinfo->texinfo->vecs[0][3]) - surface->lightmapinfo->texturemins[0]; - dt = (int) (x * surface->lightmapinfo->texinfo->vecs[1][0] + y * surface->lightmapinfo->texinfo->vecs[1][1] + mid * surface->lightmapinfo->texinfo->vecs[1][2] + surface->lightmapinfo->texinfo->vecs[1][3]) - surface->lightmapinfo->texturemins[1]; + // location we want to sample in the lightmap + ds = ((x * surface->lightmapinfo->texinfo->vecs[0][0] + y * surface->lightmapinfo->texinfo->vecs[0][1] + mid * surface->lightmapinfo->texinfo->vecs[0][2] + surface->lightmapinfo->texinfo->vecs[0][3]) - surface->lightmapinfo->texturemins[0]) * 0.0625f; + dt = ((x * surface->lightmapinfo->texinfo->vecs[1][0] + y * surface->lightmapinfo->texinfo->vecs[1][1] + mid * surface->lightmapinfo->texinfo->vecs[1][2] + surface->lightmapinfo->texinfo->vecs[1][3]) - surface->lightmapinfo->texturemins[1]) * 0.0625f; + + // check the bounds + dsi = (int)ds; + dti = (int)dt; + lmwidth = ((surface->lightmapinfo->extents[0]>>4)+1); + lmheight = ((surface->lightmapinfo->extents[1]>>4)+1); - if (ds >= 0 && ds < surface->lightmapinfo->extents[0] && dt >= 0 && dt < surface->lightmapinfo->extents[1]) + // is it in bounds? + if (dsi >= 0 && dsi < lmwidth-1 && dti >= 0 && dti < lmheight-1) { - unsigned char *lightmap; - int lmwidth, lmheight, maps, line3, size3, dsfrac = ds & 15, dtfrac = dt & 15, scale = 0, r00 = 0, g00 = 0, b00 = 0, r01 = 0, g01 = 0, b01 = 0, r10 = 0, g10 = 0, b10 = 0, r11 = 0, g11 = 0, b11 = 0; - lmwidth = ((surface->lightmapinfo->extents[0]>>4)+1); - lmheight = ((surface->lightmapinfo->extents[1]>>4)+1); + // calculate bilinear interpolation factors + // and also multiply by fixedpoint conversion factors + dsfrac = ds - dsi; + dtfrac = dt - dti; + w00 = (1 - dsfrac) * (1 - dtfrac) * (1.0f / 32768.0f); + w01 = ( dsfrac) * (1 - dtfrac) * (1.0f / 32768.0f); + w10 = (1 - dsfrac) * ( dtfrac) * (1.0f / 32768.0f); + w11 = ( dsfrac) * ( dtfrac) * (1.0f / 32768.0f); + + // values for pointer math line3 = lmwidth * 3; // LordHavoc: *3 for colored lighting size3 = lmwidth * lmheight * 3; // LordHavoc: *3 for colored lighting - lightmap = surface->lightmapinfo->samples + ((dt>>4) * lmwidth + (ds>>4))*3; // LordHavoc: *3 for colored lighting + // look up the pixel + lightmap = surface->lightmapinfo->samples + dti * line3 + dsi*3; // LordHavoc: *3 for colored lighting + // bilinear filter each lightmap style, and sum them for (maps = 0;maps < MAXLIGHTMAPS && surface->lightmapinfo->styles[maps] != 255;maps++) { - scale = r_refdef.lightstylevalue[surface->lightmapinfo->styles[maps]]; - r00 += lightmap[ 0] * scale;g00 += lightmap[ 1] * scale;b00 += lightmap[ 2] * scale; - r01 += lightmap[ 3] * scale;g01 += lightmap[ 4] * scale;b01 += lightmap[ 5] * scale; - r10 += lightmap[line3+0] * scale;g10 += lightmap[line3+1] * scale;b10 += lightmap[line3+2] * scale; - r11 += lightmap[line3+3] * scale;g11 += lightmap[line3+4] * scale;b11 += lightmap[line3+5] * scale; + scale = r_refdef.scene.lightstylevalue[surface->lightmapinfo->styles[maps]]; + w = w00 * scale;VectorMA(ambientcolor, w, lightmap , ambientcolor); + w = w01 * scale;VectorMA(ambientcolor, w, lightmap + 3 , ambientcolor); + w = w10 * scale;VectorMA(ambientcolor, w, lightmap + line3 , ambientcolor); + w = w11 * scale;VectorMA(ambientcolor, w, lightmap + line3 + 3, ambientcolor); lightmap += size3; } -/* -LordHavoc: here's the readable version of the interpolation -code, not quite as easy for the compiler to optimize... - -dsfrac is the X position in the lightmap pixel, * 16 -dtfrac is the Y position in the lightmap pixel, * 16 -r00 is top left corner, r01 is top right corner -r10 is bottom left corner, r11 is bottom right corner -g and b are the same layout. -r0 and r1 are the top and bottom intermediate results - -first we interpolate the top two points, to get the top -edge sample - - r0 = (((r01-r00) * dsfrac) >> 4) + r00; - g0 = (((g01-g00) * dsfrac) >> 4) + g00; - b0 = (((b01-b00) * dsfrac) >> 4) + b00; - -then we interpolate the bottom two points, to get the -bottom edge sample - - r1 = (((r11-r10) * dsfrac) >> 4) + r10; - g1 = (((g11-g10) * dsfrac) >> 4) + g10; - b1 = (((b11-b10) * dsfrac) >> 4) + b10; - -then we interpolate the top and bottom samples to get the -middle sample (the one which was requested) - - r = (((r1-r0) * dtfrac) >> 4) + r0; - g = (((g1-g0) * dtfrac) >> 4) + g0; - b = (((b1-b0) * dtfrac) >> 4) + b0; -*/ - - ambientcolor[0] += (float) ((((((((r11-r10) * dsfrac) >> 4) + r10)-((((r01-r00) * dsfrac) >> 4) + r00)) * dtfrac) >> 4) + ((((r01-r00) * dsfrac) >> 4) + r00)) * (1.0f / 32768.0f); - ambientcolor[1] += (float) ((((((((g11-g10) * dsfrac) >> 4) + g10)-((((g01-g00) * dsfrac) >> 4) + g00)) * dtfrac) >> 4) + ((((g01-g00) * dsfrac) >> 4) + g00)) * (1.0f / 32768.0f); - ambientcolor[2] += (float) ((((((((b11-b10) * dsfrac) >> 4) + b10)-((((b01-b00) * dsfrac) >> 4) + b00)) * dtfrac) >> 4) + ((((b01-b00) * dsfrac) >> 4) + b00)) * (1.0f / 32768.0f); return true; // success } } @@ -1191,11 +1190,19 @@ middle sample (the one which was requested) } } -void Mod_Q1BSP_LightPoint(model_t *model, const vec3_t p, vec3_t ambientcolor, vec3_t diffusecolor, vec3_t diffusenormal) +void Mod_Q1BSP_LightPoint(dp_model_t *model, const vec3_t p, vec3_t ambientcolor, vec3_t diffusecolor, vec3_t diffusenormal) { - Mod_Q1BSP_LightPoint_RecursiveBSPNode(model, ambientcolor, diffusecolor, diffusenormal, model->brush.data_nodes + model->brushq1.hulls[0].firstclipnode, p[0], p[1], p[2] + 0.125, p[2] - 65536); // pretend lighting is coming down from above (due to lack of a lightgrid to know primary lighting direction) VectorSet(diffusenormal, 0, 0, 1); + + if (!model->brushq1.lightdata) + { + VectorSet(ambientcolor, 1, 1, 1); + VectorSet(diffusecolor, 0, 0, 0); + return; + } + + Mod_Q1BSP_LightPoint_RecursiveBSPNode(model, ambientcolor, diffusecolor, diffusenormal, model->brush.data_nodes + model->brushq1.hulls[0].firstclipnode, p[0], p[1], p[2] + 0.125, p[2] - 65536); } static void Mod_Q1BSP_DecompressVis(const unsigned char *in, const unsigned char *inend, unsigned char *out, unsigned char *outend) @@ -1244,13 +1251,9 @@ void R_Q1BSP_LoadSplitSky (unsigned char *src, int width, int height, int bytesp 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; - } + // allocate a texture pool if we need it + if (loadmodel->texturepool == NULL && cls.state != ca_dedicated) + loadmodel->texturepool = R_AllocTexturePool(); if (bytesperpixel == 4) { @@ -1273,45 +1276,50 @@ void R_Q1BSP_LoadSplitSky (unsigned char *src, int width, int height, int bytesp unsigned int i; unsigned char b[4]; } - rgba; + bgra; 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]; + p = src[i*256 + j + 128]; + r += palette_rgb[p][0]; + g += palette_rgb[p][1]; + b += palette_rgb[p][2]; } } - rgba.b[0] = r/(128*128); - rgba.b[1] = g/(128*128); - rgba.b[2] = b/(128*128); - rgba.b[3] = 0; + bgra.b[2] = r/(128*128); + bgra.b[1] = g/(128*128); + bgra.b[0] = b/(128*128); + bgra.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; + solidpixels[(i*128) + j] = palette_bgra_complete[src[i*256 + j + 128]]; + p = src[i*256 + j]; + alphapixels[(i*128) + j] = p ? palette_bgra_complete[p] : bgra.i; } } } - loadmodel->brush.solidskytexture = R_LoadTexture2D(loadmodel->texturepool, "sky_solidtexture", 128, 128, (unsigned char *) solidpixels, TEXTYPE_RGBA, TEXF_PRECACHE, NULL); - loadmodel->brush.alphaskytexture = R_LoadTexture2D(loadmodel->texturepool, "sky_alphatexture", 128, 128, (unsigned char *) alphapixels, TEXTYPE_RGBA, TEXF_ALPHA | TEXF_PRECACHE, NULL); + loadmodel->brush.solidskytexture = R_LoadTexture2D(loadmodel->texturepool, "sky_solidtexture", 128, 128, (unsigned char *) solidpixels, TEXTYPE_BGRA, TEXF_PRECACHE, NULL); + loadmodel->brush.alphaskytexture = R_LoadTexture2D(loadmodel->texturepool, "sky_alphatexture", 128, 128, (unsigned char *) alphapixels, TEXTYPE_BGRA, TEXF_ALPHA | TEXF_PRECACHE, NULL); } static void Mod_Q1BSP_LoadTextures(lump_t *l) { int i, j, k, num, max, altmax, mtwidth, mtheight, *dofs, incomplete; + skinframe_t *skinframe; miptex_t *dmiptex; texture_t *tx, *tx2, *anims[10], *altanims[10]; dmiptexlump_t *m; unsigned char *data, *mtdata; const char *s; char mapname[MAX_QPATH], name[MAX_QPATH]; + unsigned char zero[4]; + + memset(zero, 0, sizeof(zero)); loadmodel->data_textures = NULL; @@ -1321,44 +1329,64 @@ static void Mod_Q1BSP_LoadTextures(lump_t *l) m = (dmiptexlump_t *)(mod_base + l->fileofs); m->nummiptex = LittleLong (m->nummiptex); loadmodel->num_textures = m->nummiptex + 2; + loadmodel->num_texturesperskin = loadmodel->num_textures; } else { m = NULL; loadmodel->num_textures = 2; + loadmodel->num_texturesperskin = loadmodel->num_textures; } loadmodel->data_textures = (texture_t *)Mem_Alloc(loadmodel->mempool, loadmodel->num_textures * sizeof(texture_t)); // fill out all slots with notexture + if (cls.state != ca_dedicated) + skinframe = R_SkinFrame_LoadMissing(); + else + skinframe = NULL; for (i = 0, tx = loadmodel->data_textures;i < loadmodel->num_textures;i++, tx++) { strlcpy(tx->name, "NO TEXTURE FOUND", sizeof(tx->name)); tx->width = 16; tx->height = 16; - tx->numskinframes = 1; - tx->skinframerate = 1; - tx->currentskinframe = tx->skinframes; - tx->skinframes[0].base = r_texture_notexture; - tx->backgroundcurrentskinframe = tx->backgroundskinframes; - tx->basematerialflags = 0; + if (cls.state != ca_dedicated) + { + tx->numskinframes = 1; + tx->skinframerate = 1; + tx->skinframes[0] = skinframe; + tx->currentskinframe = tx->skinframes[0]; + tx->basematerialflags = 0; + } + tx->basematerialflags = MATERIALFLAG_WALL; if (i == loadmodel->num_textures - 1) { - tx->basematerialflags |= MATERIALFLAG_WATER | MATERIALFLAG_LIGHTBOTHSIDES | MATERIALFLAG_NOSHADOW; + tx->basematerialflags |= MATERIALFLAG_WATERSCROLL | MATERIALFLAG_LIGHTBOTHSIDES | MATERIALFLAG_NOSHADOW; tx->supercontents = mod_q1bsp_texture_water.supercontents; tx->surfaceflags = mod_q1bsp_texture_water.surfaceflags; } else { - tx->basematerialflags |= MATERIALFLAG_WALL; tx->supercontents = mod_q1bsp_texture_solid.supercontents; tx->surfaceflags = mod_q1bsp_texture_solid.surfaceflags; } tx->currentframe = tx; + + // clear water settings + tx->reflectmin = 0; + tx->reflectmax = 1; + tx->refractfactor = 1; + Vector4Set(tx->refractcolor4f, 1, 1, 1, 1); + tx->reflectfactor = 1; + Vector4Set(tx->reflectcolor4f, 1, 1, 1, 1); + tx->r_water_wateralpha = 1; } if (!m) + { + Con_Printf("%s: no miptex lump to load textures from\n", loadmodel->name); return; + } s = loadmodel->name; if (!strncasecmp(s, "maps/", 5)) @@ -1371,15 +1399,28 @@ static void Mod_Q1BSP_LoadTextures(lump_t *l) for (i = 0;i < m->nummiptex;i++) { dofs[i] = LittleLong(dofs[i]); - if (dofs[i] == -1 || r_nosurftextures.integer) + if (r_nosurftextures.integer) + continue; + if (dofs[i] == -1) + { + Con_DPrintf("%s: miptex #%i missing\n", loadmodel->name, i); continue; + } dmiptex = (miptex_t *)((unsigned char *)m + dofs[i]); - // make sure name is no more than 15 characters - for (j = 0;dmiptex->name[j] && j < 15;j++) + // copy name, but only up to 16 characters + // (the output buffer can hold more than this, but the input buffer is + // only 16) + for (j = 0;j < 16 && dmiptex->name[j];j++) name[j] = dmiptex->name[j]; name[j] = 0; + if (!name[0]) + { + dpsnprintf(name, sizeof(name), "unnamed%i", i); + Con_DPrintf("%s: warning: renaming unnamed texture to %s\n", loadmodel->name, name); + } + mtwidth = LittleLong(dmiptex->width); mtheight = LittleLong(dmiptex->height); mtdata = NULL; @@ -1389,29 +1430,55 @@ static void Mod_Q1BSP_LoadTextures(lump_t *l) // texture included if (j < 40 || j + mtwidth * mtheight > l->filelen) { - Con_Printf("Texture \"%s\" in \"%s\"is corrupt or incomplete\n", dmiptex->name, loadmodel->name); + Con_Printf("%s: Texture \"%s\" is corrupt or incomplete\n", loadmodel->name, dmiptex->name); continue; } mtdata = (unsigned char *)dmiptex + j; } if ((mtwidth & 15) || (mtheight & 15)) - Con_Printf("warning: texture \"%s\" in \"%s\" is not 16 aligned\n", dmiptex->name, loadmodel->name); + Con_DPrintf("%s: warning: texture \"%s\" is not 16 aligned\n", loadmodel->name, dmiptex->name); // LordHavoc: force all names to lowercase for (j = 0;name[j];j++) if (name[j] >= 'A' && name[j] <= 'Z') name[j] += 'a' - 'A'; + if (dmiptex->name[0] && Mod_LoadTextureFromQ3Shader(loadmodel->data_textures + i, name, false, false, 0)) + continue; + tx = loadmodel->data_textures + i; strlcpy(tx->name, name, sizeof(tx->name)); tx->width = mtwidth; tx->height = mtheight; - if (!tx->name[0]) + if (tx->name[0] == '*') { - sprintf(tx->name, "unnamed%i", i); - Con_Printf("warning: unnamed texture in %s, renaming to %s\n", loadmodel->name, tx->name); + if (!strncmp(tx->name, "*lava", 5)) + { + tx->supercontents = mod_q1bsp_texture_lava.supercontents; + tx->surfaceflags = mod_q1bsp_texture_lava.surfaceflags; + } + else if (!strncmp(tx->name, "*slime", 6)) + { + tx->supercontents = mod_q1bsp_texture_slime.supercontents; + tx->surfaceflags = mod_q1bsp_texture_slime.surfaceflags; + } + else + { + tx->supercontents = mod_q1bsp_texture_water.supercontents; + tx->surfaceflags = mod_q1bsp_texture_water.surfaceflags; + } + } + else if (!strncmp(tx->name, "sky", 3)) + { + tx->supercontents = mod_q1bsp_texture_sky.supercontents; + tx->surfaceflags = mod_q1bsp_texture_sky.surfaceflags; + } + else + { + tx->supercontents = mod_q1bsp_texture_solid.supercontents; + tx->surfaceflags = mod_q1bsp_texture_solid.surfaceflags; } if (cls.state != ca_dedicated) @@ -1421,8 +1488,8 @@ static void Mod_Q1BSP_LoadTextures(lump_t *l) { if (loadmodel->isworldmodel) { - data = loadimagepixels(tx->name, false, 0, 0); - if (data) + data = loadimagepixelsbgra(tx->name, false, false); + if (data && image_width == 256 && image_height == 128) { R_Q1BSP_LoadSplitSky(data, image_width, image_height, 4); Mem_Free(data); @@ -1433,8 +1500,10 @@ static void Mod_Q1BSP_LoadTextures(lump_t *l) } else { - if (!Mod_LoadSkinFrame(&tx->skinframes[0], gamemode == GAME_TENEBRAE ? tx->name : va("textures/%s/%s", mapname, tx->name), TEXF_MIPMAP | TEXF_ALPHA | TEXF_PRECACHE | TEXF_PICMIP, false, true) - && !Mod_LoadSkinFrame(&tx->skinframes[0], gamemode == GAME_TENEBRAE ? tx->name : va("textures/%s", tx->name), TEXF_MIPMAP | TEXF_ALPHA | TEXF_PRECACHE | TEXF_PICMIP, false, true)) + skinframe = R_SkinFrame_LoadExternal(gamemode == GAME_TENEBRAE ? tx->name : va("textures/%s/%s", mapname, tx->name), TEXF_MIPMAP | TEXF_PRECACHE | (r_picmipworld.integer ? TEXF_PICMIP : 0) | TEXF_COMPRESS, false); + if (!skinframe) + skinframe = R_SkinFrame_LoadExternal(gamemode == GAME_TENEBRAE ? tx->name : va("textures/%s", tx->name), TEXF_MIPMAP | TEXF_PRECACHE | (r_picmipworld.integer ? TEXF_PICMIP : 0) | TEXF_COMPRESS, false); + if (!skinframe) { // did not find external texture, load it from the bsp or wad3 if (loadmodel->brush.ishlbsp) @@ -1443,73 +1512,63 @@ static void Mod_Q1BSP_LoadTextures(lump_t *l) unsigned char *pixels, *freepixels; pixels = freepixels = NULL; if (mtdata) - pixels = W_ConvertWAD3Texture(dmiptex); + pixels = W_ConvertWAD3TextureBGRA(dmiptex); if (pixels == NULL) - pixels = freepixels = W_GetTexture(tx->name); + pixels = freepixels = W_GetTextureBGRA(tx->name); if (pixels != NULL) { tx->width = image_width; tx->height = image_height; - Mod_LoadSkinFrame_Internal(&tx->skinframes[0], tx->name, TEXF_MIPMAP | TEXF_ALPHA | TEXF_PRECACHE | TEXF_PICMIP, false, false, pixels, image_width, image_height, 32, NULL, NULL); + skinframe = R_SkinFrame_LoadInternalBGRA(tx->name, TEXF_MIPMAP | TEXF_PRECACHE | (r_picmipworld.integer ? TEXF_PICMIP : 0), pixels, image_width, image_height); } if (freepixels) Mem_Free(freepixels); } else if (mtdata) // texture included - Mod_LoadSkinFrame_Internal(&tx->skinframes[0], tx->name, TEXF_MIPMAP | TEXF_PRECACHE | TEXF_PICMIP, false, r_fullbrights.integer, mtdata, tx->width, tx->height, 8, NULL, NULL); + skinframe = R_SkinFrame_LoadInternalQuake(tx->name, TEXF_MIPMAP | TEXF_PRECACHE | (r_picmipworld.integer ? TEXF_PICMIP : 0), false, r_fullbrights.integer, mtdata, tx->width, tx->height); } + // if skinframe is still NULL the "missing" texture will be used + if (skinframe) + tx->skinframes[0] = skinframe; } - if (tx->skinframes[0].base == NULL) - { - // no texture found - tx->width = 16; - tx->height = 16; - tx->skinframes[0].base = r_texture_notexture; - } - } - tx->basematerialflags = 0; - if (tx->name[0] == '*') - { - // LordHavoc: some turbulent textures should not be affected by wateralpha - if (strncmp(tx->name,"*lava",5) - && strncmp(tx->name,"*teleport",9) - && strncmp(tx->name,"*rift",5)) // Scourge of Armagon texture - tx->basematerialflags |= MATERIALFLAG_WATERALPHA | MATERIALFLAG_NOSHADOW; - if (!strncmp(tx->name, "*lava", 5)) - { - tx->supercontents = mod_q1bsp_texture_lava.supercontents; - tx->surfaceflags = mod_q1bsp_texture_lava.surfaceflags; - } - else if (!strncmp(tx->name, "*slime", 6)) + tx->basematerialflags = MATERIALFLAG_WALL; + if (tx->name[0] == '*') { - tx->supercontents = mod_q1bsp_texture_slime.supercontents; - tx->surfaceflags = mod_q1bsp_texture_slime.surfaceflags; + // LordHavoc: some turbulent textures should not be affected by wateralpha + if (!strncmp(tx->name, "*glassmirror", 12)) // Tenebrae + { + // replace the texture with transparent black + Vector4Set(zero, 128, 128, 128, 128); + tx->skinframes[0] = R_SkinFrame_LoadInternalBGRA(tx->name, TEXF_MIPMAP | TEXF_PRECACHE | TEXF_ALPHA, zero, 1, 1); + tx->basematerialflags |= MATERIALFLAG_NOSHADOW | MATERIALFLAG_ADD | MATERIALFLAG_BLENDED | MATERIALFLAG_REFLECTION; + } + else if (!strncmp(tx->name,"*lava",5) + || !strncmp(tx->name,"*teleport",9) + || !strncmp(tx->name,"*rift",5)) // Scourge of Armagon texture + tx->basematerialflags |= MATERIALFLAG_WATERSCROLL | MATERIALFLAG_LIGHTBOTHSIDES | MATERIALFLAG_NOSHADOW; + else + tx->basematerialflags |= MATERIALFLAG_WATERSCROLL | MATERIALFLAG_LIGHTBOTHSIDES | MATERIALFLAG_NOSHADOW | MATERIALFLAG_WATERALPHA | MATERIALFLAG_WATERSHADER; + if (tx->skinframes[0] && tx->skinframes[0]->fog) + tx->basematerialflags |= MATERIALFLAG_ALPHA | MATERIALFLAG_BLENDED | MATERIALFLAG_NOSHADOW; } - else + else if (!strncmp(tx->name, "mirror", 6)) // Tenebrae { - tx->supercontents = mod_q1bsp_texture_water.supercontents; - tx->surfaceflags = mod_q1bsp_texture_water.surfaceflags; + // replace the texture with black + tx->skinframes[0] = R_SkinFrame_LoadInternalBGRA(tx->name, TEXF_PRECACHE, zero, 1, 1); + tx->basematerialflags |= MATERIALFLAG_REFLECTION; } - tx->basematerialflags |= MATERIALFLAG_WATER | MATERIALFLAG_LIGHTBOTHSIDES | MATERIALFLAG_NOSHADOW; - } - else if (tx->name[0] == 's' && tx->name[1] == 'k' && tx->name[2] == 'y') - { - tx->supercontents = mod_q1bsp_texture_sky.supercontents; - tx->surfaceflags = mod_q1bsp_texture_sky.surfaceflags; - tx->basematerialflags |= MATERIALFLAG_SKY | MATERIALFLAG_NOSHADOW; - } - else - { - tx->supercontents = mod_q1bsp_texture_solid.supercontents; - tx->surfaceflags = mod_q1bsp_texture_solid.surfaceflags; - tx->basematerialflags |= MATERIALFLAG_WALL; - } - if (tx->skinframes[0].fog) - tx->basematerialflags |= MATERIALFLAG_ALPHA | MATERIALFLAG_BLENDED | MATERIALFLAG_TRANSPARENT | MATERIALFLAG_NOSHADOW; + else if (!strncmp(tx->name, "sky", 3)) + tx->basematerialflags = MATERIALFLAG_SKY | MATERIALFLAG_NOSHADOW; + else if (!strcmp(tx->name, "caulk")) + tx->basematerialflags = MATERIALFLAG_NODRAW; + else if (tx->skinframes[0] && tx->skinframes[0]->fog) + tx->basematerialflags |= MATERIALFLAG_ALPHA | MATERIALFLAG_BLENDED | MATERIALFLAG_NOSHADOW; - // start out with no animation - tx->currentframe = tx; + // start out with no animation + tx->currentframe = tx; + tx->currentskinframe = tx->skinframes[0]; + } } // sequence the animations @@ -1627,11 +1686,6 @@ static void Mod_Q1BSP_LoadLighting(lump_t *l) for (i=0; ifilelen; i++) loadmodel->brushq1.lightdata[i] = mod_base[l->fileofs+i] >>= 1; } - else if (loadmodel->brush.ismcbsp) - { - loadmodel->brushq1.lightdata = (unsigned char *)Mem_Alloc(loadmodel->mempool, l->filelen); - memcpy(loadmodel->brushq1.lightdata, mod_base + l->fileofs, l->filelen); - } else // LordHavoc: bsp version 29 (normal white lighting) { // LordHavoc: hope is not lost yet, check for a .lit file to load @@ -1648,7 +1702,8 @@ static void Mod_Q1BSP_LoadLighting(lump_t *l) i = LittleLong(((int *)data)[1]); if (i == 1) { - Con_DPrintf("loaded %s\n", litfilename); + if (developer_loading.integer) + Con_Printf("loaded %s\n", litfilename); loadmodel->brushq1.lightdata = (unsigned char *)Mem_Alloc(loadmodel->mempool, filesize - 8); memcpy(loadmodel->brushq1.lightdata, data + 8, filesize - 8); Mem_Free(data); @@ -1660,7 +1715,8 @@ static void Mod_Q1BSP_LoadLighting(lump_t *l) i = LittleLong(((int *)data)[1]); if (i == 1) { - Con_DPrintf("loaded %s\n", dlitfilename); + if (developer_loading.integer) + Con_Printf("loaded %s\n", dlitfilename); loadmodel->brushq1.nmaplightdata = (unsigned char *)Mem_Alloc(loadmodel->mempool, filesize - 8); memcpy(loadmodel->brushq1.nmaplightdata, data + 8, filesize - 8); loadmodel->brushq3.deluxemapping_modelspace = false; @@ -1720,13 +1776,13 @@ static void Mod_Q1BSP_ParseWadsFromEntityLump(const char *data) int i, j, k; if (!data) return; - if (!COM_ParseTokenConsole(&data)) + if (!COM_ParseToken_Simple(&data, false, false)) return; // error if (com_token[0] != '{') return; // error while (1) { - if (!COM_ParseTokenConsole(&data)) + if (!COM_ParseToken_Simple(&data, false, false)) return; // error if (com_token[0] == '}') break; // end of worldspawn @@ -1736,7 +1792,7 @@ static void Mod_Q1BSP_ParseWadsFromEntityLump(const char *data) strlcpy(key, com_token, sizeof(key)); while (key[strlen(key)-1] == ' ') // remove trailing spaces key[strlen(key)-1] = 0; - if (!COM_ParseTokenConsole(&data)) + if (!COM_ParseToken_Simple(&data, false, false)) return; // error dpsnprintf(value, sizeof(value), "%s", com_token); if (!strcmp("wad", key)) // for HalfLife maps @@ -1931,7 +1987,7 @@ static void Mod_Q1BSP_LoadTexinfo(lump_t *l) { // if texture chosen is NULL or the shader needs a lightmap, // force to notexture water shader - if (out->texture == NULL || out->texture->basematerialflags & MATERIALFLAG_WALL) + if (out->texture == NULL) out->texture = loadmodel->data_textures + (loadmodel->num_textures - 1); } else @@ -2095,46 +2151,78 @@ static void Mod_Q1BSP_GenerateWarpMesh(msurface_t *surface) } #endif -static qboolean Mod_Q1BSP_AllocLightmapBlock(int *lineused, int totalwidth, int totalheight, int blockwidth, int blockheight, int *outx, int *outy) +/* Maximum size of a single LM */ +#define MAX_SINGLE_LM_SIZE 256 + +struct alloc_lm_row +{ + int rowY; + int currentX; +}; + +struct alloc_lm_state { - int y, x2, y2; - int bestx = totalwidth, besty = 0; - // find the left-most space we can find - for (y = 0;y <= totalheight - blockheight;y++) - { - x2 = 0; - for (y2 = 0;y2 < blockheight;y2++) - x2 = max(x2, lineused[y+y2]); - if (bestx > x2) - { - bestx = x2; - besty = y; - } - } - // if the best was not good enough, return failure - if (bestx > totalwidth - blockwidth) - return false; - // we found a good spot - if (outx) - *outx = bestx; - if (outy) - *outy = besty; - // now mark the space used - for (y2 = 0;y2 < blockheight;y2++) - lineused[besty+y2] = bestx + blockwidth; - // return success + int currentY; + struct alloc_lm_row rows[MAX_SINGLE_LM_SIZE]; +}; + +static void init_alloc_lm_state (struct alloc_lm_state* state) +{ + int r; + + state->currentY = 0; + for (r = 0; r < MAX_SINGLE_LM_SIZE; r++) + { + state->rows[r].currentX = 0; + state->rows[r].rowY = -1; + } +} + +static qboolean Mod_Q1BSP_AllocLightmapBlock(struct alloc_lm_state* state, int totalwidth, int totalheight, int blockwidth, int blockheight, int *outx, int *outy) +{ + struct alloc_lm_row* row; + int r; + + row = &(state->rows[blockheight]); + if ((row->rowY < 0) || (row->currentX + blockwidth > totalwidth)) + { + if (state->currentY + blockheight <= totalheight) + { + row->rowY = state->currentY; + row->currentX = 0; + state->currentY += blockheight; + } + else + { + /* See if we can stuff the block into a higher row */ + row = NULL; + for (r = blockheight; r < MAX_SINGLE_LM_SIZE; r++) + { + if ((state->rows[r].rowY >= 0) + && (state->rows[r].currentX + blockwidth <= totalwidth)) + { + row = &(state->rows[r]); + break; + } + } + if (row == NULL) return false; + } + } + *outy = row->rowY; + *outx = row->currentX; + row->currentX += blockwidth; + return true; } +extern cvar_t gl_max_size; static void Mod_Q1BSP_LoadFaces(lump_t *l) { dface_t *in; msurface_t *surface; - int i, j, count, surfacenum, planenum, smax, tmax, ssize, tsize, firstedge, numedges, totalverts, totaltris, lightmapnumber; - float texmins[2], texmaxs[2], val, lightmaptexcoordscale; -#define LIGHTMAPSIZE 256 + int i, j, count, surfacenum, planenum, smax, tmax, ssize, tsize, firstedge, numedges, totalverts, totaltris, lightmapnumber, lightmapsize, totallightmapsamples; + float texmins[2], texmaxs[2], val; rtexture_t *lightmaptexture, *deluxemaptexture; - int lightmap_lineused[LIGHTMAPSIZE]; in = (dface_t *)(mod_base + l->fileofs); if (l->filelen % sizeof(*in)) @@ -2145,11 +2233,13 @@ static void Mod_Q1BSP_LoadFaces(lump_t *l) loadmodel->num_surfaces = count; + loadmodel->brushq1.lightmapupdateflags = (unsigned char *)Mem_Alloc(loadmodel->mempool, count*sizeof(unsigned char)); + totalverts = 0; totaltris = 0; for (surfacenum = 0, in = (dface_t *)(mod_base + l->fileofs);surfacenum < count;surfacenum++, in++) { - numedges = LittleShort(in->numedges); + numedges = (unsigned short)LittleShort(in->numedges); totalverts += numedges; totaltris += numedges - 2; } @@ -2159,7 +2249,8 @@ static void Mod_Q1BSP_LoadFaces(lump_t *l) lightmaptexture = NULL; deluxemaptexture = r_texture_blanknormalmap; lightmapnumber = 1; - lightmaptexcoordscale = 1.0f / (float)LIGHTMAPSIZE; + lightmapsize = max(256, gl_max_size.integer); + totallightmapsamples = 0; totalverts = 0; totaltris = 0; @@ -2169,16 +2260,16 @@ static void Mod_Q1BSP_LoadFaces(lump_t *l) // FIXME: validate edges, texinfo, etc? firstedge = LittleLong(in->firstedge); - numedges = LittleShort(in->numedges); + numedges = (unsigned short)LittleShort(in->numedges); if ((unsigned int) firstedge > (unsigned int) loadmodel->brushq1.numsurfedges || (unsigned int) numedges > (unsigned int) loadmodel->brushq1.numsurfedges || (unsigned int) firstedge + (unsigned int) numedges > (unsigned int) loadmodel->brushq1.numsurfedges) Host_Error("Mod_Q1BSP_LoadFaces: invalid edge range (firstedge %i, numedges %i, model edges %i)", firstedge, numedges, loadmodel->brushq1.numsurfedges); - i = LittleShort(in->texinfo); + i = (unsigned short)LittleShort(in->texinfo); if ((unsigned int) i >= (unsigned int) loadmodel->brushq1.numtexinfo) Host_Error("Mod_Q1BSP_LoadFaces: invalid texinfo index %i(model has %i texinfos)", i, loadmodel->brushq1.numtexinfo); surface->lightmapinfo->texinfo = loadmodel->brushq1.texinfo + i; surface->texture = surface->lightmapinfo->texinfo->texture; - planenum = LittleShort(in->planenum); + planenum = (unsigned short)LittleShort(in->planenum); if ((unsigned int) planenum >= (unsigned int) loadmodel->brush.num_planes) Host_Error("Mod_Q1BSP_LoadFaces: invalid plane index %i (model has %i planes)", planenum, loadmodel->brush.num_planes); @@ -2257,7 +2348,7 @@ static void Mod_Q1BSP_LoadFaces(lump_t *l) { surface->lightmapinfo->samples = NULL; // give non-lightmapped water a 1x white lightmap - if ((surface->texture->basematerialflags & MATERIALFLAG_WATER) && (surface->lightmapinfo->texinfo->flags & TEX_SPECIAL) && ssize <= 256 && tsize <= 256) + if (surface->texture->name[0] == '*' && (surface->lightmapinfo->texinfo->flags & TEX_SPECIAL) && ssize <= 256 && tsize <= 256) { surface->lightmapinfo->samples = (unsigned char *)Mem_Alloc(loadmodel->mempool, ssize * tsize * 3); surface->lightmapinfo->styles[0] = 0; @@ -2276,39 +2367,73 @@ static void Mod_Q1BSP_LoadFaces(lump_t *l) // check if we should apply a lightmap to this if (!(surface->lightmapinfo->texinfo->flags & TEX_SPECIAL) || surface->lightmapinfo->samples) { - int i, iu, iv, lightmapx, lightmapy; - float u, v, ubase, vbase, uscale, vscale; - if (ssize > 256 || tsize > 256) Host_Error("Bad surface extents"); + + if (lightmapsize < ssize) + lightmapsize = ssize; + if (lightmapsize < tsize) + lightmapsize = tsize; + + totallightmapsamples += ssize*tsize; + // force lightmap upload on first time seeing the surface - surface->cached_dlight = true; - // stainmap for permanent marks on walls - surface->lightmapinfo->stainsamples = (unsigned char *)Mem_Alloc(loadmodel->mempool, ssize * tsize * 3); - // clear to white - memset(surface->lightmapinfo->stainsamples, 255, ssize * tsize * 3); - - // find a place for this lightmap - if (!lightmaptexture || !Mod_Q1BSP_AllocLightmapBlock(lightmap_lineused, LIGHTMAPSIZE, LIGHTMAPSIZE, ssize, tsize, &lightmapx, &lightmapy)) + // + // additionally this is used by the later code to see if a + // lightmap is needed on this surface (rather than duplicating the + // logic above) + loadmodel->brushq1.lightmapupdateflags[surfacenum] = true; + } + } + + // small maps (such as ammo boxes especially) don't need big lightmap + // textures, so this code tries to guess a good size based on + // totallightmapsamples (size of the lightmaps lump basically), as well as + // trying to max out the gl_max_size if there is a lot of lightmap data to + // store + // additionally, never choose a lightmapsize that is smaller than the + // largest surface encountered (as it would fail) + i = lightmapsize; + for (lightmapsize = 64; (lightmapsize < i) && (lightmapsize < gl_max_size.integer) && (totallightmapsamples > lightmapsize*lightmapsize); lightmapsize*=2) + ; + + // now that we've decided the lightmap texture size, we can do the rest + if (cls.state != ca_dedicated) + { + struct alloc_lm_state allocState; + + for (surfacenum = 0, surface = loadmodel->data_surfaces;surfacenum < count;surfacenum++, surface++) + { + int i, iu, iv, lightmapx = 0, lightmapy = 0; + float u, v, ubase, vbase, uscale, vscale; + + smax = surface->lightmapinfo->extents[0] >> 4; + tmax = surface->lightmapinfo->extents[1] >> 4; + ssize = (surface->lightmapinfo->extents[0] >> 4) + 1; + tsize = (surface->lightmapinfo->extents[1] >> 4) + 1; + + if (!lightmaptexture || !Mod_Q1BSP_AllocLightmapBlock(&allocState, lightmapsize, lightmapsize, ssize, tsize, &lightmapx, &lightmapy)) { + // allocate a texture pool if we need it + if (loadmodel->texturepool == NULL) + loadmodel->texturepool = R_AllocTexturePool(); // could not find room, make a new lightmap - lightmaptexture = R_LoadTexture2D(loadmodel->texturepool, va("lightmap%i", lightmapnumber), LIGHTMAPSIZE, LIGHTMAPSIZE, NULL, loadmodel->brushq1.lightmaprgba ? TEXTYPE_RGBA : TEXTYPE_RGB, TEXF_FORCELINEAR | TEXF_PRECACHE, NULL); + lightmaptexture = R_LoadTexture2D(loadmodel->texturepool, va("lightmap%i", lightmapnumber), lightmapsize, lightmapsize, NULL, TEXTYPE_BGRA, TEXF_FORCELINEAR | TEXF_PRECACHE, NULL); if (loadmodel->brushq1.nmaplightdata) - deluxemaptexture = R_LoadTexture2D(loadmodel->texturepool, va("deluxemap%i", lightmapnumber), LIGHTMAPSIZE, LIGHTMAPSIZE, NULL, loadmodel->brushq1.lightmaprgba ? TEXTYPE_RGBA : TEXTYPE_RGB, TEXF_FORCELINEAR | TEXF_PRECACHE, NULL); + deluxemaptexture = R_LoadTexture2D(loadmodel->texturepool, va("deluxemap%i", lightmapnumber), lightmapsize, lightmapsize, NULL, TEXTYPE_BGRA, TEXF_FORCELINEAR | TEXF_PRECACHE, NULL); lightmapnumber++; - memset(lightmap_lineused, 0, sizeof(lightmap_lineused)); - Mod_Q1BSP_AllocLightmapBlock(lightmap_lineused, LIGHTMAPSIZE, LIGHTMAPSIZE, ssize, tsize, &lightmapx, &lightmapy); + init_alloc_lm_state (&allocState); + Mod_Q1BSP_AllocLightmapBlock(&allocState, lightmapsize, lightmapsize, ssize, tsize, &lightmapx, &lightmapy); } - surface->lightmaptexture = lightmaptexture; surface->deluxemaptexture = deluxemaptexture; surface->lightmapinfo->lightmaporigin[0] = lightmapx; surface->lightmapinfo->lightmaporigin[1] = lightmapy; - ubase = lightmapx * lightmaptexcoordscale; - vbase = lightmapy * lightmaptexcoordscale; - uscale = lightmaptexcoordscale; - vscale = lightmaptexcoordscale; + uscale = 1.0f / (float)lightmapsize; + vscale = 1.0f / (float)lightmapsize; + ubase = lightmapx * uscale; + vbase = lightmapy * vscale; for (i = 0;i < surface->num_vertices;i++) { @@ -2321,8 +2446,38 @@ static void Mod_Q1BSP_LoadFaces(lump_t *l) iv = (int) v; (loadmodel->surfmesh.data_lightmapoffsets + surface->num_firstvertex)[i] = (bound(0, iv, tmax) * ssize + bound(0, iu, smax)) * 3; } + + } + + if (cl_stainmaps.integer) + { + // allocate stainmaps for permanent marks on walls + int stainmapsize = 0; + unsigned char *stainsamples = NULL; + for (surfacenum = 0, surface = loadmodel->data_surfaces;surfacenum < count;surfacenum++, surface++) + { + ssize = (surface->lightmapinfo->extents[0] >> 4) + 1; + tsize = (surface->lightmapinfo->extents[1] >> 4) + 1; + stainmapsize += ssize * tsize * 3; + } + // allocate and clear to white + stainsamples = (unsigned char *)Mem_Alloc(loadmodel->mempool, stainmapsize); + memset(stainsamples, 255, stainmapsize); + // assign pointers + for (surfacenum = 0, surface = loadmodel->data_surfaces;surfacenum < count;surfacenum++, surface++) + { + ssize = (surface->lightmapinfo->extents[0] >> 4) + 1; + tsize = (surface->lightmapinfo->extents[1] >> 4) + 1; + surface->lightmapinfo->stainsamples = stainsamples; + stainsamples += ssize * tsize * 3; + } } } + + // generate ushort elements array if possible + if (loadmodel->surfmesh.data_element3s) + for (i = 0;i < loadmodel->surfmesh.num_triangles*3;i++) + loadmodel->surfmesh.data_element3s[i] = loadmodel->surfmesh.data_element3i[i]; } static void Mod_Q1BSP_LoadNodes_RecursiveSetParent(mnode_t *node, mnode_t *parent) @@ -2388,16 +2543,40 @@ static void Mod_Q1BSP_LoadNodes(lump_t *l) p = LittleLong(in->planenum); out->plane = loadmodel->brush.data_planes + p; - out->firstsurface = LittleShort(in->firstface); - out->numsurfaces = LittleShort(in->numfaces); + out->firstsurface = (unsigned short)LittleShort(in->firstface); + out->numsurfaces = (unsigned short)LittleShort(in->numfaces); for (j=0 ; j<2 ; j++) { - p = LittleShort(in->children[j]); - if (p >= 0) - out->children[j] = loadmodel->brush.data_nodes + p; + // LordHavoc: this code supports broken bsp files produced by + // arguire qbsp which can produce more than 32768 nodes, any value + // below count is assumed to be a node number, any other value is + // assumed to be a leaf number + p = (unsigned short)LittleShort(in->children[j]); + if (p < count) + { + if (p < loadmodel->brush.num_nodes) + out->children[j] = loadmodel->brush.data_nodes + p; + else + { + Con_Printf("Mod_Q1BSP_LoadNodes: invalid node index %i (file has only %i nodes)\n", p, loadmodel->brush.num_nodes); + // map it to the solid leaf + out->children[j] = (mnode_t *)loadmodel->brush.data_leafs; + } + } else - out->children[j] = (mnode_t *)(loadmodel->brush.data_leafs + (-1 - p)); + { + // note this uses 65535 intentionally, -1 is leaf 0 + p = 65535 - p; + if (p < loadmodel->brush.num_leafs) + out->children[j] = (mnode_t *)(loadmodel->brush.data_leafs + p); + else + { + Con_Printf("Mod_Q1BSP_LoadNodes: invalid leaf index %i (file has only %i leafs)\n", p, loadmodel->brush.num_leafs); + // map it to the solid leaf + out->children[j] = (mnode_t *)loadmodel->brush.data_leafs; + } + } } } @@ -2436,9 +2615,9 @@ static void Mod_Q1BSP_LoadLeafs(lump_t *l) out->contents = LittleLong(in->contents); - out->firstleafsurface = loadmodel->brush.data_leafsurfaces + LittleShort(in->firstmarksurface); - out->numleafsurfaces = LittleShort(in->nummarksurfaces); - if (out->firstleafsurface < 0 || LittleShort(in->firstmarksurface) + out->numleafsurfaces > loadmodel->brush.num_leafsurfaces) + out->firstleafsurface = loadmodel->brush.data_leafsurfaces + (unsigned short)LittleShort(in->firstmarksurface); + out->numleafsurfaces = (unsigned short)LittleShort(in->nummarksurfaces); + if (out->firstleafsurface < 0 || (unsigned short)LittleShort(in->firstmarksurface) + out->numleafsurfaces > loadmodel->brush.num_leafsurfaces) { Con_Printf("Mod_Q1BSP_LoadLeafs: invalid leafsurface range %i:%i outside range %i:%i\n", (int)(out->firstleafsurface - loadmodel->brush.data_leafsurfaces), (int)(out->firstleafsurface + out->numleafsurfaces - loadmodel->brush.data_leafsurfaces), 0, loadmodel->brush.num_leafsurfaces); out->firstleafsurface = NULL; @@ -2471,11 +2650,14 @@ qboolean Mod_Q1BSP_CheckWaterAlphaSupport(void) int i, j; mleaf_t *leaf; const unsigned char *pvs; + // if there's no vis data, assume supported (because everything is visible all the time) + if (!loadmodel->brush.data_pvsclusters) + return true; // check all liquid leafs to see if they can see into empty leafs, if any // can we can assume this map supports r_wateralpha for (i = 0, leaf = loadmodel->brush.data_leafs;i < loadmodel->brush.num_leafs;i++, leaf++) { - if ((leaf->contents == CONTENTS_WATER || leaf->contents == CONTENTS_SLIME) && (leaf->clusterindex >= 0 && loadmodel->brush.data_pvsclusters)) + if ((leaf->contents == CONTENTS_WATER || leaf->contents == CONTENTS_SLIME) && leaf->clusterindex >= 0) { pvs = loadmodel->brush.data_pvsclusters + leaf->clusterindex * loadmodel->brush.num_pvsclusterbytes; for (j = 0;j < loadmodel->brush.num_leafs;j++) @@ -2488,7 +2670,8 @@ qboolean Mod_Q1BSP_CheckWaterAlphaSupport(void) static void Mod_Q1BSP_LoadClipnodes(lump_t *l, hullinfo_t *hullinfo) { - dclipnode_t *in, *out; + dclipnode_t *in; + mclipnode_t *out; int i, count; hull_t *hull; @@ -2496,12 +2679,12 @@ static void Mod_Q1BSP_LoadClipnodes(lump_t *l, hullinfo_t *hullinfo) if (l->filelen % sizeof(*in)) Host_Error("Mod_Q1BSP_LoadClipnodes: funny lump size in %s",loadmodel->name); count = l->filelen / sizeof(*in); - out = (dclipnode_t *)Mem_Alloc(loadmodel->mempool, count*sizeof(*out)); + out = (mclipnode_t *)Mem_Alloc(loadmodel->mempool, count*sizeof(*out)); loadmodel->brushq1.clipnodes = out; loadmodel->brushq1.numclipnodes = count; - for (i = 1; i < hullinfo->numhulls; i++) + for (i = 1; i < MAX_MAP_HULLS; i++) { hull = &loadmodel->brushq1.hulls[i]; hull->clipnodes = out; @@ -2520,12 +2703,15 @@ static void Mod_Q1BSP_LoadClipnodes(lump_t *l, hullinfo_t *hullinfo) for (i=0 ; iplanenum = LittleLong(in->planenum); - out->children[0] = LittleShort(in->children[0]); - out->children[1] = LittleShort(in->children[1]); + // LordHavoc: this code supports arguire qbsp's broken clipnodes indices (more than 32768 clipnodes), values above count are assumed to be contents values + out->children[0] = (unsigned short)LittleShort(in->children[0]); + out->children[1] = (unsigned short)LittleShort(in->children[1]); + if (out->children[0] >= count) + out->children[0] -= 65536; + if (out->children[1] >= count) + out->children[1] -= 65536; if (out->planenum < 0 || out->planenum >= loadmodel->brush.num_planes) Host_Error("Corrupt clipping hull(out of range planenum)"); - if (out->children[0] >= count || out->children[1] >= count) - Host_Error("Corrupt clipping hull(out of range child)"); } } @@ -2533,14 +2719,14 @@ static void Mod_Q1BSP_LoadClipnodes(lump_t *l, hullinfo_t *hullinfo) static void Mod_Q1BSP_MakeHull0(void) { mnode_t *in; - dclipnode_t *out; + mclipnode_t *out; int i; hull_t *hull; hull = &loadmodel->brushq1.hulls[0]; in = loadmodel->brush.data_nodes; - out = (dclipnode_t *)Mem_Alloc(loadmodel->mempool, loadmodel->brush.num_nodes * sizeof(dclipnode_t)); + out = (mclipnode_t *)Mem_Alloc(loadmodel->mempool, loadmodel->brush.num_nodes * sizeof(*out)); hull->clipnodes = out; hull->firstclipnode = 0; @@ -2568,7 +2754,7 @@ static void Mod_Q1BSP_LoadLeaffaces(lump_t *l) for (i = 0;i < loadmodel->brush.num_leafsurfaces;i++) { - j = (unsigned) LittleShort(in[i]); + j = (unsigned short) LittleShort(in[i]); if (j >= loadmodel->num_surfaces) Host_Error("Mod_Q1BSP_LoadLeaffaces: bad surface number"); loadmodel->brush.data_leafsurfaces[i] = j; @@ -2629,12 +2815,12 @@ static void Mod_Q1BSP_LoadMapBrushes(void) if (!maptext) return; text = maptext; - if (!COM_ParseTokenConsole(&data)) + if (!COM_ParseToken_Simple(&data, false, false)) return; // error submodel = 0; for (;;) { - if (!COM_ParseTokenConsole(&data)) + if (!COM_ParseToken_Simple(&data, false, false)) break; if (com_token[0] != '{') return; // error @@ -2645,7 +2831,7 @@ static void Mod_Q1BSP_LoadMapBrushes(void) brushes = Mem_Alloc(loadmodel->mempool, maxbrushes * sizeof(mbrush_t)); for (;;) { - if (!COM_ParseTokenConsole(&data)) + if (!COM_ParseToken_Simple(&data, false, false)) return; // error if (com_token[0] == '}') break; // end of entity @@ -2669,7 +2855,7 @@ static void Mod_Q1BSP_LoadMapBrushes(void) } for (;;) { - if (!COM_ParseTokenConsole(&data)) + if (!COM_ParseToken_Simple(&data, false, false)) return; // error if (com_token[0] == '}') break; // end of brush @@ -2678,25 +2864,25 @@ static void Mod_Q1BSP_LoadMapBrushes(void) // FIXME: support hl .map format for (pointnum = 0;pointnum < 3;pointnum++) { - COM_ParseTokenConsole(&data); + COM_ParseToken_Simple(&data, false, false); for (componentnum = 0;componentnum < 3;componentnum++) { - COM_ParseTokenConsole(&data); + COM_ParseToken_Simple(&data, false, false); point[pointnum][componentnum] = atof(com_token); } - COM_ParseTokenConsole(&data); + COM_ParseToken_Simple(&data, false, false); } - COM_ParseTokenConsole(&data); + COM_ParseToken_Simple(&data, false, false); strlcpy(facetexture, com_token, sizeof(facetexture)); - COM_ParseTokenConsole(&data); + COM_ParseToken_Simple(&data, false, false); //scroll_s = atof(com_token); - COM_ParseTokenConsole(&data); + COM_ParseToken_Simple(&data, false, false); //scroll_t = atof(com_token); - COM_ParseTokenConsole(&data); + COM_ParseToken_Simple(&data, false, false); //rotate = atof(com_token); - COM_ParseTokenConsole(&data); + COM_ParseToken_Simple(&data, false, false); //scale_s = atof(com_token); - COM_ParseTokenConsole(&data); + COM_ParseToken_Simple(&data, false, false); //scale_t = atof(com_token); TriangleNormal(point[0], point[1], point[2], planenormal); VectorNormalizeDouble(planenormal); @@ -3098,62 +3284,9 @@ static void Mod_Q1BSP_MakePortals(void) Mod_Q1BSP_FinalizePortals(); } -static void Mod_Q1BSP_BuildLightmapUpdateChains(mempool_t *mempool, model_t *model) -{ - int i, j, stylecounts[256], totalcount, remapstyles[256]; - msurface_t *surface; - memset(stylecounts, 0, sizeof(stylecounts)); - for (i = 0;i < model->nummodelsurfaces;i++) - { - surface = model->data_surfaces + model->firstmodelsurface + i; - for (j = 0;j < MAXLIGHTMAPS;j++) - stylecounts[surface->lightmapinfo->styles[j]]++; - } - totalcount = 0; - model->brushq1.light_styles = 0; - for (i = 0;i < 255;i++) - { - if (stylecounts[i]) - { - remapstyles[i] = model->brushq1.light_styles++; - totalcount += stylecounts[i] + 1; - } - } - if (!totalcount) - return; - model->brushq1.light_style = (unsigned char *)Mem_Alloc(mempool, model->brushq1.light_styles * sizeof(unsigned char)); - model->brushq1.light_stylevalue = (int *)Mem_Alloc(mempool, model->brushq1.light_styles * sizeof(int)); - model->brushq1.light_styleupdatechains = (msurface_t ***)Mem_Alloc(mempool, model->brushq1.light_styles * sizeof(msurface_t **)); - model->brushq1.light_styleupdatechainsbuffer = (msurface_t **)Mem_Alloc(mempool, totalcount * sizeof(msurface_t *)); - model->brushq1.light_styles = 0; - for (i = 0;i < 255;i++) - if (stylecounts[i]) - model->brushq1.light_style[model->brushq1.light_styles++] = i; - j = 0; - for (i = 0;i < model->brushq1.light_styles;i++) - { - model->brushq1.light_styleupdatechains[i] = model->brushq1.light_styleupdatechainsbuffer + j; - j += stylecounts[model->brushq1.light_style[i]] + 1; - } - for (i = 0;i < model->nummodelsurfaces;i++) - { - surface = model->data_surfaces + model->firstmodelsurface + i; - for (j = 0;j < MAXLIGHTMAPS;j++) - if (surface->lightmapinfo->styles[j] != 255) - *model->brushq1.light_styleupdatechains[remapstyles[surface->lightmapinfo->styles[j]]]++ = surface; - } - j = 0; - for (i = 0;i < model->brushq1.light_styles;i++) - { - *model->brushq1.light_styleupdatechains[i] = NULL; - model->brushq1.light_styleupdatechains[i] = model->brushq1.light_styleupdatechainsbuffer + j; - j += stylecounts[model->brushq1.light_style[i]] + 1; - } -} - //Returns PVS data for a given point //(note: can return NULL) -static unsigned char *Mod_Q1BSP_GetPVS(model_t *model, const vec3_t p) +static unsigned char *Mod_Q1BSP_GetPVS(dp_model_t *model, const vec3_t p) { mnode_t *node; node = model->brush.data_nodes; @@ -3165,7 +3298,7 @@ static unsigned char *Mod_Q1BSP_GetPVS(model_t *model, const vec3_t p) return NULL; } -static void Mod_Q1BSP_FatPVS_RecursiveBSPNode(model_t *model, const vec3_t org, vec_t radius, unsigned char *pvsbuffer, int pvsbytes, mnode_t *node) +static void Mod_Q1BSP_FatPVS_RecursiveBSPNode(dp_model_t *model, const vec3_t org, vec_t radius, unsigned char *pvsbuffer, int pvsbytes, mnode_t *node) { while (node->plane) { @@ -3193,7 +3326,7 @@ static void Mod_Q1BSP_FatPVS_RecursiveBSPNode(model_t *model, const vec3_t org, //Calculates a PVS that is the inclusive or of all leafs within radius pixels //of the given point. -static int Mod_Q1BSP_FatPVS(model_t *model, const vec3_t org, vec_t radius, unsigned char *pvsbuffer, int pvsbufferlength) +static int Mod_Q1BSP_FatPVS(dp_model_t *model, const vec3_t org, vec_t radius, unsigned char *pvsbuffer, int pvsbufferlength, qboolean merge) { int bytes = model->brush.num_pvsclusterbytes; bytes = min(bytes, pvsbufferlength); @@ -3202,27 +3335,19 @@ static int Mod_Q1BSP_FatPVS(model_t *model, const vec3_t org, vec_t radius, unsi memset(pvsbuffer, 0xFF, bytes); return bytes; } - memset(pvsbuffer, 0, bytes); + if (!merge) + memset(pvsbuffer, 0, bytes); Mod_Q1BSP_FatPVS_RecursiveBSPNode(model, org, radius, pvsbuffer, bytes, model->brush.data_nodes); return bytes; } -static void Mod_Q1BSP_RoundUpToHullSize(model_t *cmodel, const vec3_t inmins, const vec3_t inmaxs, vec3_t outmins, vec3_t outmaxs) +static void Mod_Q1BSP_RoundUpToHullSize(dp_model_t *cmodel, const vec3_t inmins, const vec3_t inmaxs, vec3_t outmins, vec3_t outmaxs) { vec3_t size; const hull_t *hull; VectorSubtract(inmaxs, inmins, size); - if (cmodel->brush.ismcbsp) - { - if (size[0] < 3) - hull = &cmodel->brushq1.hulls[0]; // 0x0x0 - else if (size[2] < 48) // pick the nearest of 40 or 56 - hull = &cmodel->brushq1.hulls[2]; // 16x16x40 - else - hull = &cmodel->brushq1.hulls[1]; // 16x16x56 - } - else if (cmodel->brush.ishlbsp) + if (cmodel->brush.ishlbsp) { if (size[0] < 3) hull = &cmodel->brushq1.hulls[0]; // 0x0x0 @@ -3249,7 +3374,7 @@ static void Mod_Q1BSP_RoundUpToHullSize(model_t *cmodel, const vec3_t inmins, co VectorAdd(inmins, hull->clip_size, outmaxs); } -void Mod_Q1BSP_Load(model_t *mod, void *buffer, void *bufferend) +void Mod_Q1BSP_Load(dp_model_t *mod, void *buffer, void *bufferend) { int i, j, k; dheader_t *header; @@ -3258,96 +3383,57 @@ void Mod_Q1BSP_Load(model_t *mod, void *buffer, void *bufferend) float dist, modelyawradius, modelradius, *vec; msurface_t *surface; int numshadowmeshtriangles; - dheader_t _header; hullinfo_t hullinfo; + int totalstylesurfaces, totalstyles, stylecounts[256], remapstyles[256]; + model_brush_lightstyleinfo_t styleinfo[256]; + unsigned char *datapointer; - mod->type = mod_brushq1; - - if (!memcmp (buffer, "MCBSPpad", 8)) - { - unsigned char *index; - - mod->brush.ismcbsp = true; - mod->brush.ishlbsp = false; + mod->modeldatatypestring = "Q1BSP"; - mod_base = (unsigned char*)buffer; + mod->type = mod_brushq1; - index = mod_base; - index += 8; - i = SB_ReadInt (&index); - if (i != MCBSPVERSION) - Host_Error("Mod_Q1BSP_Load: %s has wrong version number(%i should be %i)", mod->name, i, MCBSPVERSION); + header = (dheader_t *)buffer; - // read hull info - hullinfo.numhulls = LittleLong(*(int*)index); index += 4; - hullinfo.filehulls = hullinfo.numhulls; - VectorClear (hullinfo.hullsizes[0][0]); - VectorClear (hullinfo.hullsizes[0][1]); - for (i = 1; i < hullinfo.numhulls; i++) - { - hullinfo.hullsizes[i][0][0] = SB_ReadFloat (&index); - hullinfo.hullsizes[i][0][1] = SB_ReadFloat (&index); - hullinfo.hullsizes[i][0][2] = SB_ReadFloat (&index); - hullinfo.hullsizes[i][1][0] = SB_ReadFloat (&index); - hullinfo.hullsizes[i][1][1] = SB_ReadFloat (&index); - hullinfo.hullsizes[i][1][2] = SB_ReadFloat (&index); - } + i = LittleLong(header->version); + if (i != BSPVERSION && i != 30) + Host_Error("Mod_Q1BSP_Load: %s has wrong version number(%i should be %i(Quake) or 30(HalfLife)", mod->name, i, BSPVERSION); + mod->brush.ishlbsp = i == 30; - // read lumps - _header.version = 0; - for (i = 0; i < HEADER_LUMPS; i++) - { - _header.lumps[i].fileofs = SB_ReadInt (&index); - _header.lumps[i].filelen = SB_ReadInt (&index); - } +// fill in hull info + VectorClear (hullinfo.hullsizes[0][0]); + VectorClear (hullinfo.hullsizes[0][1]); + if (mod->brush.ishlbsp) + { + mod->modeldatatypestring = "HLBSP"; - header = &_header; + hullinfo.filehulls = 4; + VectorSet (hullinfo.hullsizes[1][0], -16, -16, -36); + VectorSet (hullinfo.hullsizes[1][1], 16, 16, 36); + VectorSet (hullinfo.hullsizes[2][0], -32, -32, -32); + VectorSet (hullinfo.hullsizes[2][1], 32, 32, 32); + VectorSet (hullinfo.hullsizes[3][0], -16, -16, -18); + VectorSet (hullinfo.hullsizes[3][1], 16, 16, 18); } else { - header = (dheader_t *)buffer; - - i = LittleLong(header->version); - if (i != BSPVERSION && i != 30) - Host_Error("Mod_Q1BSP_Load: %s has wrong version number(%i should be %i(Quake) or 30(HalfLife)", mod->name, i, BSPVERSION); - mod->brush.ishlbsp = i == 30; - mod->brush.ismcbsp = false; - - // fill in hull info - VectorClear (hullinfo.hullsizes[0][0]); - VectorClear (hullinfo.hullsizes[0][1]); - if (mod->brush.ishlbsp) - { - hullinfo.numhulls = 4; - hullinfo.filehulls = 4; - VectorSet (hullinfo.hullsizes[1][0], -16, -16, -36); - VectorSet (hullinfo.hullsizes[1][1], 16, 16, 36); - VectorSet (hullinfo.hullsizes[2][0], -32, -32, -32); - VectorSet (hullinfo.hullsizes[2][1], 32, 32, 32); - VectorSet (hullinfo.hullsizes[3][0], -16, -16, -18); - VectorSet (hullinfo.hullsizes[3][1], 16, 16, 18); - } - else - { - hullinfo.numhulls = 3; - hullinfo.filehulls = 4; - VectorSet (hullinfo.hullsizes[1][0], -16, -16, -24); - VectorSet (hullinfo.hullsizes[1][1], 16, 16, 32); - VectorSet (hullinfo.hullsizes[2][0], -32, -32, -24); - VectorSet (hullinfo.hullsizes[2][1], 32, 32, 64); - } + hullinfo.filehulls = 4; + VectorSet (hullinfo.hullsizes[1][0], -16, -16, -24); + VectorSet (hullinfo.hullsizes[1][1], 16, 16, 32); + VectorSet (hullinfo.hullsizes[2][0], -32, -32, -24); + VectorSet (hullinfo.hullsizes[2][1], 32, 32, 64); + } - // read lumps - mod_base = (unsigned char*)buffer; - 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); - } +// read lumps + mod_base = (unsigned char*)buffer; + 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); } mod->soundfromcenter = true; mod->TraceBox = Mod_Q1BSP_TraceBox; + mod->PointSuperContents = Mod_Q1BSP_PointSuperContents; mod->brush.TraceLineOfSight = Mod_Q1BSP_TraceLineOfSight; mod->brush.SuperContentsFromNativeContents = Mod_Q1BSP_SuperContentsFromNativeContents; mod->brush.NativeContentsFromSuperContents = Mod_Q1BSP_NativeContentsFromSuperContents; @@ -3364,16 +3450,10 @@ void Mod_Q1BSP_Load(model_t *mod, void *buffer, void *bufferend) mod->brush.PointInLeaf = Mod_Q1BSP_PointInLeaf; if (loadmodel->isworldmodel) - { Cvar_SetValue("halflifebsp", mod->brush.ishlbsp); - Cvar_SetValue("mcbsp", mod->brush.ismcbsp); - } // load into heap - // store which lightmap format to use - mod->brushq1.lightmaprgba = r_lightmaprgba.integer; - mod->brush.qw_md4sum = 0; mod->brush.qw_md4sum2 = 0; for (i = 0;i < HEADER_LUMPS;i++) @@ -3406,9 +3486,6 @@ void Mod_Q1BSP_Load(model_t *mod, void *buffer, void *bufferend) // check if the map supports transparent water rendering loadmodel->brush.supportwateralpha = Mod_Q1BSP_CheckWaterAlphaSupport(); - if (!mod->brushq1.lightdata) - mod->brush.LightPoint = NULL; - if (mod->brushq1.data_compressedpvs) Mem_Free(mod->brushq1.data_compressedpvs); mod->brushq1.data_compressedpvs = NULL; @@ -3432,19 +3509,11 @@ void Mod_Q1BSP_Load(model_t *mod, void *buffer, void *bufferend) loadmodel->brush.shadowmesh = Mod_ShadowMesh_Begin(loadmodel->mempool, numshadowmeshtriangles * 3, numshadowmeshtriangles, NULL, NULL, NULL, false, false, true); for (j = 0, surface = loadmodel->data_surfaces;j < loadmodel->num_surfaces;j++, surface++) Mod_ShadowMesh_AddMesh(loadmodel->mempool, loadmodel->brush.shadowmesh, NULL, NULL, NULL, loadmodel->surfmesh.data_vertex3f, NULL, NULL, NULL, NULL, surface->num_triangles, (loadmodel->surfmesh.data_element3i + 3 * surface->num_firsttriangle)); - loadmodel->brush.shadowmesh = Mod_ShadowMesh_Finish(loadmodel->mempool, loadmodel->brush.shadowmesh, false, true); + loadmodel->brush.shadowmesh = Mod_ShadowMesh_Finish(loadmodel->mempool, loadmodel->brush.shadowmesh, false, true, false); Mod_BuildTriangleNeighbors(loadmodel->brush.shadowmesh->neighbor3i, loadmodel->brush.shadowmesh->element3i, loadmodel->brush.shadowmesh->numtriangles); if (loadmodel->brush.numsubmodels) - loadmodel->brush.submodels = (model_t **)Mem_Alloc(loadmodel->mempool, loadmodel->brush.numsubmodels * sizeof(model_t *)); - - if (loadmodel->isworldmodel) - { - // clear out any stale submodels or worldmodels lying around - // if we did this clear before now, an error might abort loading and - // leave things in a bad state - Mod_RemoveStaleWorldModels(loadmodel); - } + loadmodel->brush.submodels = (dp_model_t **)Mem_Alloc(loadmodel->mempool, loadmodel->brush.numsubmodels * sizeof(dp_model_t *)); // LordHavoc: to clear the fog around the original quake submodel code, I // will explain: @@ -3460,6 +3529,25 @@ void Mod_Q1BSP_Load(model_t *mod, void *buffer, void *bufferend) // 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. + totalstylesurfaces = 0; + totalstyles = 0; + for (i = 0;i < mod->brush.numsubmodels;i++) + { + memset(stylecounts, 0, sizeof(stylecounts)); + for (k = 0;k < mod->brushq1.submodels[i].numfaces;k++) + { + surface = mod->data_surfaces + mod->brushq1.submodels[i].firstface + k; + for (j = 0;j < MAXLIGHTMAPS;j++) + stylecounts[surface->lightmapinfo->styles[j]]++; + } + for (k = 0;k < 255;k++) + { + totalstyles++; + if (stylecounts[k]) + totalstylesurfaces += stylecounts[k]; + } + } + datapointer = (unsigned char *)Mem_Alloc(mod->mempool, mod->num_surfaces * sizeof(int) + totalstyles * sizeof(model_brush_lightstyleinfo_t) + totalstylesurfaces * sizeof(int *)); for (i = 0;i < mod->brush.numsubmodels;i++) { // LordHavoc: this code was originally at the end of this loop, but @@ -3474,7 +3562,7 @@ void Mod_Q1BSP_Load(model_t *mod, void *buffer, void *bufferend) if (!loadmodel->isworldmodel) continue; // duplicate the basic information - sprintf(name, "*%i", i); + dpsnprintf(name, sizeof(name), "*%i", i); mod = Mod_FindName(name); // copy the base model to this one *mod = *loadmodel; @@ -3503,13 +3591,16 @@ void Mod_Q1BSP_Load(model_t *mod, void *buffer, void *bufferend) mod->nummodelsurfaces = bm->numfaces; // make the model surface list (used by shadowing/lighting) - mod->surfacelist = (int *)Mem_Alloc(loadmodel->mempool, mod->nummodelsurfaces * sizeof(*mod->surfacelist)); + mod->surfacelist = (int *)datapointer;datapointer += mod->nummodelsurfaces * sizeof(int); for (j = 0;j < mod->nummodelsurfaces;j++) mod->surfacelist[j] = mod->firstmodelsurface + j; - // this gets altered below if sky is used + // this gets altered below if sky or water is used mod->DrawSky = NULL; + mod->DrawAddWaterPlanes = NULL; mod->Draw = R_Q1BSP_Draw; + mod->DrawDepth = R_Q1BSP_DrawDepth; + mod->DrawDebug = R_Q1BSP_DrawDebug; mod->GetLightInfo = R_Q1BSP_GetLightInfo; mod->CompileShadowVolume = R_Q1BSP_CompileShadowVolume; mod->DrawShadowVolume = R_Q1BSP_DrawShadowVolume; @@ -3526,12 +3617,15 @@ void Mod_Q1BSP_Load(model_t *mod, void *buffer, void *bufferend) mod->brush.LightPoint = NULL; mod->brush.AmbientSoundLevelsForPoint = NULL; } - Mod_Q1BSP_BuildLightmapUpdateChains(loadmodel->mempool, mod); + // copy the submodel bounds, then enlarge the yaw and rotated bounds according to radius + VectorCopy(bm->mins, mod->normalmins); + VectorCopy(bm->maxs, mod->normalmaxs); + VectorCopy(bm->mins, mod->yawmins); + VectorCopy(bm->maxs, mod->yawmaxs); + VectorCopy(bm->mins, mod->rotatedmins); + VectorCopy(bm->maxs, mod->rotatedmaxs); 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, surface = &mod->data_surfaces[mod->firstmodelsurface];j < mod->nummodelsurfaces;j++, surface++) @@ -3539,15 +3633,11 @@ void Mod_Q1BSP_Load(model_t *mod, void *buffer, void *bufferend) // we only need to have a drawsky function if it is used(usually only on world model) if (surface->texture->basematerialflags & MATERIALFLAG_SKY) mod->DrawSky = R_Q1BSP_DrawSky; + if (surface->texture->basematerialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION | MATERIALFLAG_REFLECTION)) + mod->DrawAddWaterPlanes = R_Q1BSP_DrawAddWaterPlanes; // calculate bounding shapes for (k = 0, vec = (loadmodel->surfmesh.data_vertex3f + 3 * surface->num_firstvertex);k < surface->num_vertices;k++, vec += 3) { - if (mod->normalmins[0] > vec[0]) mod->normalmins[0] = vec[0]; - if (mod->normalmins[1] > vec[1]) mod->normalmins[1] = vec[1]; - if (mod->normalmins[2] > vec[2]) mod->normalmins[2] = vec[2]; - if (mod->normalmaxs[0] < vec[0]) mod->normalmaxs[0] = vec[0]; - if (mod->normalmaxs[1] < vec[1]) mod->normalmaxs[1] = vec[1]; - if (mod->normalmaxs[2] < vec[2]) mod->normalmaxs[2] = vec[2]; dist = vec[0]*vec[0]+vec[1]*vec[1]; if (modelyawradius < dist) modelyawradius = dist; @@ -3558,13 +3648,56 @@ void Mod_Q1BSP_Load(model_t *mod, void *buffer, void *bufferend) } modelyawradius = sqrt(modelyawradius); modelradius = sqrt(modelradius); - mod->yawmins[0] = mod->yawmins[1] = - (mod->yawmaxs[0] = mod->yawmaxs[1] = modelyawradius); - mod->yawmins[2] = mod->normalmins[2]; - mod->yawmaxs[2] = mod->normalmaxs[2]; - mod->rotatedmins[0] = mod->rotatedmins[1] = mod->rotatedmins[2] = -modelradius; - mod->rotatedmaxs[0] = mod->rotatedmaxs[1] = mod->rotatedmaxs[2] = modelradius; + mod->yawmins[0] = min(mod->yawmins[0], -modelyawradius); + mod->yawmaxs[0] = min(mod->yawmaxs[0], -modelyawradius); + mod->yawmins[1] = min(mod->yawmins[1], modelyawradius); + mod->yawmaxs[1] = min(mod->yawmaxs[1], modelyawradius); + mod->rotatedmins[0] = min(mod->rotatedmins[0], -modelradius); + mod->rotatedmaxs[0] = min(mod->rotatedmaxs[0], modelradius); + mod->rotatedmins[1] = min(mod->rotatedmins[1], -modelradius); + mod->rotatedmaxs[1] = min(mod->rotatedmaxs[1], modelradius); + mod->rotatedmins[2] = min(mod->rotatedmins[2], -modelradius); + mod->rotatedmaxs[2] = min(mod->rotatedmaxs[2], modelradius); mod->radius = modelradius; mod->radius2 = modelradius * modelradius; + + // build lightstyle update chains + // (used to rapidly mark lightmapupdateflags on many surfaces + // when d_lightstylevalue changes) + memset(stylecounts, 0, sizeof(stylecounts)); + for (k = 0;k < mod->nummodelsurfaces;k++) + { + surface = mod->data_surfaces + mod->firstmodelsurface + k; + for (j = 0;j < MAXLIGHTMAPS;j++) + stylecounts[surface->lightmapinfo->styles[j]]++; + } + mod->brushq1.num_lightstyles = 0; + for (k = 0;k < 255;k++) + { + if (stylecounts[k]) + { + styleinfo[mod->brushq1.num_lightstyles].style = k; + styleinfo[mod->brushq1.num_lightstyles].value = 0; + styleinfo[mod->brushq1.num_lightstyles].numsurfaces = 0; + styleinfo[mod->brushq1.num_lightstyles].surfacelist = (int *)datapointer;datapointer += stylecounts[k] * sizeof(int); + remapstyles[k] = mod->brushq1.num_lightstyles; + mod->brushq1.num_lightstyles++; + } + } + for (k = 0;k < mod->nummodelsurfaces;k++) + { + surface = mod->data_surfaces + mod->firstmodelsurface + k; + for (j = 0;j < MAXLIGHTMAPS;j++) + { + if (surface->lightmapinfo->styles[j] != 255) + { + int r = remapstyles[surface->lightmapinfo->styles[j]]; + styleinfo[r].surfacelist[styleinfo[r].numsurfaces++] = mod->firstmodelsurface + k; + } + } + } + mod->brushq1.data_lightstyleinfo = (model_brush_lightstyleinfo_t *)datapointer;datapointer += mod->brushq1.num_lightstyles * sizeof(model_brush_lightstyleinfo_t); + memcpy(mod->brushq1.data_lightstyleinfo, styleinfo, mod->brushq1.num_lightstyles * sizeof(model_brush_lightstyleinfo_t)); } else { @@ -3960,13 +4093,15 @@ static void Mod_Q2BSP_LoadModels(lump_t *l) */ } -void static Mod_Q2BSP_Load(model_t *mod, void *buffer, void *bufferend) +void static Mod_Q2BSP_Load(dp_model_t *mod, void *buffer, void *bufferend) { int i; q2dheader_t *header; Host_Error("Mod_Q2BSP_Load: not yet implemented"); + mod->modeldatatypestring = "Q2BSP"; + mod->type = mod_brushq2; header = (q2dheader_t *)buffer; @@ -3975,12 +4110,8 @@ void static Mod_Q2BSP_Load(model_t *mod, void *buffer, void *bufferend) if (i != Q2BSPVERSION) Host_Error("Mod_Q2BSP_Load: %s has wrong version number (%i, should be %i)", mod->name, i, Q2BSPVERSION); mod->brush.ishlbsp = false; - mod->brush.ismcbsp = false; if (loadmodel->isworldmodel) - { Cvar_SetValue("halflifebsp", mod->brush.ishlbsp); - Cvar_SetValue("mcbsp", mod->brush.ismcbsp); - } mod_base = (unsigned char *)header; @@ -3988,9 +4119,6 @@ void static Mod_Q2BSP_Load(model_t *mod, void *buffer, void *bufferend) for (i = 0;i < (int) sizeof(*header) / 4;i++) ((int *)header)[i] = LittleLong(((int *)header)[i]); - // store which lightmap format to use - mod->brushq1.lightmaprgba = r_lightmaprgba.integer; - mod->brush.qw_md4sum = 0; mod->brush.qw_md4sum2 = 0; for (i = 0;i < Q2HEADER_LUMPS;i++) @@ -4024,8 +4152,8 @@ void static Mod_Q2BSP_Load(model_t *mod, void *buffer, void *bufferend) Mod_Q2BSP_LoadModels(&header->lumps[Q2LUMP_MODELS]); } -static int Mod_Q3BSP_SuperContentsFromNativeContents(model_t *model, int nativecontents); -static int Mod_Q3BSP_NativeContentsFromSuperContents(model_t *model, int supercontents); +static int Mod_Q3BSP_SuperContentsFromNativeContents(dp_model_t *model, int nativecontents); +static int Mod_Q3BSP_NativeContentsFromSuperContents(dp_model_t *model, int supercontents); static void Mod_Q3BSP_LoadEntities(lump_t *l) { @@ -4041,11 +4169,11 @@ static void Mod_Q3BSP_LoadEntities(lump_t *l) memcpy(loadmodel->brush.entities, mod_base + l->fileofs, l->filelen); data = loadmodel->brush.entities; // some Q3 maps override the lightgrid_cellsize with a worldspawn key - if (data && COM_ParseTokenConsole(&data) && com_token[0] == '{') + if (data && COM_ParseToken_Simple(&data, false, false) && com_token[0] == '{') { while (1) { - if (!COM_ParseTokenConsole(&data)) + if (!COM_ParseToken_Simple(&data, false, false)) break; // error if (com_token[0] == '}') break; // end of worldspawn @@ -4055,11 +4183,14 @@ static void Mod_Q3BSP_LoadEntities(lump_t *l) strlcpy(key, com_token, sizeof(key)); while (key[strlen(key)-1] == ' ') // remove trailing spaces key[strlen(key)-1] = 0; - if (!COM_ParseTokenConsole(&data)) + if (!COM_ParseToken_Simple(&data, false, false)) break; // error strlcpy(value, com_token, sizeof(value)); if (!strcmp("gridsize", key)) { +#if _MSC_VER >= 1400 +#define sscanf sscanf_s +#endif if (sscanf(value, "%f %f %f", &v[0], &v[1], &v[2]) == 3 && v[0] != 0 && v[1] != 0 && v[2] != 0) VectorCopy(v, loadmodel->brushq3.num_lightgrid_cellsize); } @@ -4067,367 +4198,11 @@ static void Mod_Q3BSP_LoadEntities(lump_t *l) } } -// FIXME: make MAXSHADERS dynamic -#define Q3SHADER_MAXSHADERS 4096 -#define Q3SHADER_MAXLAYERS 8 - -typedef struct q3shaderinfo_layer_s -{ - int alphatest; - int clampmap; - float framerate; - int numframes; - char texturename[TEXTURE_MAXFRAMES][Q3PATHLENGTH]; - int blendfunc[2]; - qboolean rgbgenvertex; - qboolean alphagenvertex; -} -q3shaderinfo_layer_t; - -typedef struct q3shaderinfo_s -{ - char name[Q3PATHLENGTH]; - int surfaceparms; - int textureflags; - int numlayers; - qboolean lighting; - qboolean vertexalpha; - qboolean textureblendalpha; - q3shaderinfo_layer_t *primarylayer, *backgroundlayer; - q3shaderinfo_layer_t layers[Q3SHADER_MAXLAYERS]; - char skyboxname[Q3PATHLENGTH]; -} -q3shaderinfo_t; - -int q3shaders_numshaders; -q3shaderinfo_t q3shaders_shaders[Q3SHADER_MAXSHADERS]; - -static void Mod_Q3BSP_LoadShaders(void) -{ - int j; - int fileindex; - fssearch_t *search; - char *f; - const char *text; - q3shaderinfo_t *shader; - q3shaderinfo_layer_t *layer; - int numparameters; - char parameter[TEXTURE_MAXFRAMES + 4][Q3PATHLENGTH]; - search = FS_Search("scripts/*.shader", true, false); - if (!search) - return; - q3shaders_numshaders = 0; - for (fileindex = 0;fileindex < search->numfilenames;fileindex++) - { - text = f = (char *)FS_LoadFile(search->filenames[fileindex], tempmempool, false, NULL); - if (!f) - continue; - while (COM_ParseToken(&text, false)) - { - if (q3shaders_numshaders >= Q3SHADER_MAXSHADERS) - { - Con_Printf("Mod_Q3BSP_LoadShaders: too many shaders!\n"); - break; - } - shader = q3shaders_shaders + q3shaders_numshaders++; - memset(shader, 0, sizeof(*shader)); - strlcpy(shader->name, com_token, sizeof(shader->name)); - if (!COM_ParseToken(&text, false) || strcasecmp(com_token, "{")) - { - Con_Printf("%s parsing error - expected \"{\", found \"%s\"\n", search->filenames[fileindex], com_token); - break; - } - while (COM_ParseToken(&text, false)) - { - if (!strcasecmp(com_token, "}")) - break; - if (!strcasecmp(com_token, "{")) - { - if (shader->numlayers < Q3SHADER_MAXLAYERS) - { - layer = shader->layers + shader->numlayers++; - layer->rgbgenvertex = false; - layer->alphagenvertex = false; - layer->blendfunc[0] = GL_ONE; - layer->blendfunc[1] = GL_ZERO; - } - else - layer = NULL; - while (COM_ParseToken(&text, false)) - { - if (!strcasecmp(com_token, "}")) - break; - if (!strcasecmp(com_token, "\n")) - continue; - if (layer == NULL) - continue; - numparameters = 0; - for (j = 0;strcasecmp(com_token, "\n") && strcasecmp(com_token, "}");j++) - { - if (j < TEXTURE_MAXFRAMES + 4) - { - strlcpy(parameter[j], com_token, sizeof(parameter[j])); - numparameters = j + 1; - } - if (!COM_ParseToken(&text, true)) - break; - } - if (developer.integer >= 100) - { - Con_Printf("%s %i: ", shader->name, shader->numlayers - 1); - for (j = 0;j < numparameters;j++) - Con_Printf(" %s", parameter[j]); - Con_Print("\n"); - } - if (numparameters >= 2 && !strcasecmp(parameter[0], "blendfunc")) - { - if (numparameters == 2) - { - if (!strcasecmp(parameter[1], "add")) - { - layer->blendfunc[0] = GL_ONE; - layer->blendfunc[1] = GL_ONE; - } - else if (!strcasecmp(parameter[1], "filter")) - { - layer->blendfunc[0] = GL_DST_COLOR; - layer->blendfunc[1] = GL_ZERO; - } - else if (!strcasecmp(parameter[1], "blend")) - { - layer->blendfunc[0] = GL_SRC_ALPHA; - layer->blendfunc[1] = GL_ONE_MINUS_SRC_ALPHA; - } - } - else if (numparameters == 3) - { - int k; - for (k = 0;k < 2;k++) - { - if (!strcasecmp(parameter[k+1], "GL_ONE")) - layer->blendfunc[k] = GL_ONE; - else if (!strcasecmp(parameter[k+1], "GL_ZERO")) - layer->blendfunc[k] = GL_ZERO; - else if (!strcasecmp(parameter[k+1], "GL_SRC_COLOR")) - layer->blendfunc[k] = GL_SRC_COLOR; - else if (!strcasecmp(parameter[k+1], "GL_SRC_ALPHA")) - layer->blendfunc[k] = GL_SRC_ALPHA; - else if (!strcasecmp(parameter[k+1], "GL_DST_COLOR")) - layer->blendfunc[k] = GL_DST_COLOR; - else if (!strcasecmp(parameter[k+1], "GL_DST_ALPHA")) - layer->blendfunc[k] = GL_ONE_MINUS_DST_ALPHA; - else if (!strcasecmp(parameter[k+1], "GL_ONE_MINUS_SRC_COLOR")) - layer->blendfunc[k] = GL_ONE_MINUS_SRC_COLOR; - else if (!strcasecmp(parameter[k+1], "GL_ONE_MINUS_SRC_ALPHA")) - layer->blendfunc[k] = GL_ONE_MINUS_SRC_ALPHA; - else if (!strcasecmp(parameter[k+1], "GL_ONE_MINUS_DST_COLOR")) - layer->blendfunc[k] = GL_ONE_MINUS_DST_COLOR; - else if (!strcasecmp(parameter[k+1], "GL_ONE_MINUS_DST_ALPHA")) - layer->blendfunc[k] = GL_ONE_MINUS_DST_ALPHA; - else - layer->blendfunc[k] = GL_ONE; // default in case of parsing error - } - } - } - if (numparameters >= 2 && !strcasecmp(parameter[0], "alphafunc")) - layer->alphatest = true; - if (numparameters >= 2 && (!strcasecmp(parameter[0], "map") || !strcasecmp(parameter[0], "clampmap"))) - { - if (!strcasecmp(parameter[0], "clampmap")) - layer->clampmap = true; - layer->numframes = 1; - layer->framerate = 1; - strlcpy(layer->texturename[0], parameter[1], sizeof(layer->texturename)); - if (!strcasecmp(parameter[1], "$lightmap")) - shader->lighting = true; - } - else if (numparameters >= 3 && (!strcasecmp(parameter[0], "animmap") || !strcasecmp(parameter[0], "animclampmap"))) - { - int i; - layer->numframes = min(numparameters - 2, TEXTURE_MAXFRAMES); - layer->framerate = atof(parameter[1]); - for (i = 0;i < layer->numframes;i++) - strlcpy(layer->texturename[i], parameter[i + 2], sizeof(layer->texturename)); - } - else if (numparameters >= 2 && !strcasecmp(parameter[0], "rgbgen") && !strcasecmp(parameter[1], "vertex")) - layer->rgbgenvertex = true; - else if (numparameters >= 2 && !strcasecmp(parameter[0], "alphagen") && !strcasecmp(parameter[1], "vertex")) - layer->alphagenvertex = true; - // break out a level if it was } - if (!strcasecmp(com_token, "}")) - break; - } - if (layer->rgbgenvertex) - shader->lighting = true; - if (layer->alphagenvertex) - { - if (layer == shader->layers + 0) - { - // vertex controlled transparency - shader->vertexalpha = true; - } - else - { - // multilayer terrain shader or similar - shader->textureblendalpha = true; - } - } - continue; - } - numparameters = 0; - for (j = 0;strcasecmp(com_token, "\n") && strcasecmp(com_token, "}");j++) - { - if (j < TEXTURE_MAXFRAMES + 4) - { - strlcpy(parameter[j], com_token, sizeof(parameter[j])); - numparameters = j + 1; - } - if (!COM_ParseToken(&text, true)) - break; - } - if (fileindex == 0 && !strcasecmp(com_token, "}")) - break; - if (developer.integer >= 100) - { - Con_Printf("%s: ", shader->name); - 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")) - shader->surfaceparms |= Q3SURFACEPARM_ALPHASHADOW; - else if (!strcasecmp(parameter[1], "areaportal")) - shader->surfaceparms |= Q3SURFACEPARM_AREAPORTAL; - else if (!strcasecmp(parameter[1], "botclip")) - shader->surfaceparms |= Q3SURFACEPARM_BOTCLIP; - else if (!strcasecmp(parameter[1], "clusterportal")) - shader->surfaceparms |= Q3SURFACEPARM_CLUSTERPORTAL; - else if (!strcasecmp(parameter[1], "detail")) - shader->surfaceparms |= Q3SURFACEPARM_DETAIL; - else if (!strcasecmp(parameter[1], "donotenter")) - shader->surfaceparms |= Q3SURFACEPARM_DONOTENTER; - else if (!strcasecmp(parameter[1], "dust")) - shader->surfaceparms |= Q3SURFACEPARM_DUST; - else if (!strcasecmp(parameter[1], "hint")) - shader->surfaceparms |= Q3SURFACEPARM_HINT; - else if (!strcasecmp(parameter[1], "fog")) - shader->surfaceparms |= Q3SURFACEPARM_FOG; - else if (!strcasecmp(parameter[1], "lava")) - shader->surfaceparms |= Q3SURFACEPARM_LAVA; - else if (!strcasecmp(parameter[1], "lightfilter")) - shader->surfaceparms |= Q3SURFACEPARM_LIGHTFILTER; - else if (!strcasecmp(parameter[1], "lightgrid")) - shader->surfaceparms |= Q3SURFACEPARM_LIGHTGRID; - else if (!strcasecmp(parameter[1], "metalsteps")) - shader->surfaceparms |= Q3SURFACEPARM_METALSTEPS; - else if (!strcasecmp(parameter[1], "nodamage")) - shader->surfaceparms |= Q3SURFACEPARM_NODAMAGE; - else if (!strcasecmp(parameter[1], "nodlight")) - shader->surfaceparms |= Q3SURFACEPARM_NODLIGHT; - else if (!strcasecmp(parameter[1], "nodraw")) - shader->surfaceparms |= Q3SURFACEPARM_NODRAW; - else if (!strcasecmp(parameter[1], "nodrop")) - shader->surfaceparms |= Q3SURFACEPARM_NODROP; - else if (!strcasecmp(parameter[1], "noimpact")) - shader->surfaceparms |= Q3SURFACEPARM_NOIMPACT; - else if (!strcasecmp(parameter[1], "nolightmap")) - shader->surfaceparms |= Q3SURFACEPARM_NOLIGHTMAP; - else if (!strcasecmp(parameter[1], "nomarks")) - shader->surfaceparms |= Q3SURFACEPARM_NOMARKS; - else if (!strcasecmp(parameter[1], "nomipmaps")) - shader->surfaceparms |= Q3SURFACEPARM_NOMIPMAPS; - else if (!strcasecmp(parameter[1], "nonsolid")) - shader->surfaceparms |= Q3SURFACEPARM_NONSOLID; - else if (!strcasecmp(parameter[1], "origin")) - shader->surfaceparms |= Q3SURFACEPARM_ORIGIN; - else if (!strcasecmp(parameter[1], "playerclip")) - shader->surfaceparms |= Q3SURFACEPARM_PLAYERCLIP; - else if (!strcasecmp(parameter[1], "sky")) - shader->surfaceparms |= Q3SURFACEPARM_SKY; - else if (!strcasecmp(parameter[1], "slick")) - shader->surfaceparms |= Q3SURFACEPARM_SLICK; - else if (!strcasecmp(parameter[1], "slime")) - shader->surfaceparms |= Q3SURFACEPARM_SLIME; - else if (!strcasecmp(parameter[1], "structural")) - shader->surfaceparms |= Q3SURFACEPARM_STRUCTURAL; - else if (!strcasecmp(parameter[1], "trans")) - shader->surfaceparms |= Q3SURFACEPARM_TRANS; - else if (!strcasecmp(parameter[1], "water")) - shader->surfaceparms |= Q3SURFACEPARM_WATER; - else if (!strcasecmp(parameter[1], "pointlight")) - shader->surfaceparms |= Q3SURFACEPARM_POINTLIGHT; - else if (!strcasecmp(parameter[1], "antiportal")) - shader->surfaceparms |= Q3SURFACEPARM_ANTIPORTAL; - else - Con_DPrintf("%s parsing warning: unknown surfaceparm \"%s\"\n", search->filenames[fileindex], parameter[1]); - } - else if (!strcasecmp(parameter[0], "sky") && numparameters >= 2) - { - // some q3 skies don't have the sky parm set - shader->surfaceparms |= Q3SURFACEPARM_SKY; - strlcpy(shader->skyboxname, parameter[1], sizeof(shader->skyboxname)); - } - else if (!strcasecmp(parameter[0], "skyparms") && numparameters >= 2) - { - // some q3 skies don't have the sky parm set - shader->surfaceparms |= Q3SURFACEPARM_SKY; - if (!atoi(parameter[1]) && strcasecmp(parameter[1], "-")) - strlcpy(shader->skyboxname, parameter[1], sizeof(shader->skyboxname)); - } - else if (!strcasecmp(parameter[0], "cull") && numparameters >= 2) - { - if (!strcasecmp(parameter[1], "disable") || !strcasecmp(parameter[1], "none") || !strcasecmp(parameter[1], "twosided")) - shader->textureflags |= Q3TEXTUREFLAG_TWOSIDED; - } - else if (!strcasecmp(parameter[0], "nomipmaps")) - shader->surfaceparms |= Q3SURFACEPARM_NOMIPMAPS; - else if (!strcasecmp(parameter[0], "nopicmip")) - shader->textureflags |= Q3TEXTUREFLAG_NOPICMIP; - else if (!strcasecmp(parameter[0], "deformvertexes") && numparameters >= 2) - { - if (!strcasecmp(parameter[1], "autosprite") && numparameters == 2) - shader->textureflags |= Q3TEXTUREFLAG_AUTOSPRITE; - if (!strcasecmp(parameter[1], "autosprite2") && numparameters == 2) - shader->textureflags |= Q3TEXTUREFLAG_AUTOSPRITE2; - } - } - // identify if this is a blended terrain shader or similar - if (shader->numlayers) - { - shader->primarylayer = shader->layers + 0; - if ((shader->layers[1].blendfunc[0] == GL_SRC_ALPHA && shader->layers[1].blendfunc[1] == GL_ONE_MINUS_SRC_ALPHA) || shader->layers[1].alphatest) - { - // terrain blending or other effects - shader->backgroundlayer = shader->layers + 0; - shader->primarylayer = shader->layers + 1; - } - // now see if the lightmap came first, and if so choose the second texture instead - if (!strcasecmp(shader->primarylayer->texturename[0], "$lightmap")) - shader->primarylayer = shader->layers + 1; - } - } - Mem_Free(f); - } -} - -q3shaderinfo_t *Mod_Q3BSP_LookupShader(const char *name) -{ - int i; - for (i = 0;i < Q3SHADER_MAXSHADERS;i++) - if (!strcasecmp(q3shaders_shaders[i].name, name)) - return q3shaders_shaders + i; - return NULL; -} - static void Mod_Q3BSP_LoadTextures(lump_t *l) { q3dtexture_t *in; texture_t *out; - int i, count, c; + int i, count; in = (q3dtexture_t *)(mod_base + l->fileofs); if (l->filelen % sizeof(*in)) @@ -4437,138 +4212,20 @@ static void Mod_Q3BSP_LoadTextures(lump_t *l) loadmodel->data_textures = out; loadmodel->num_textures = count; + loadmodel->num_texturesperskin = loadmodel->num_textures; + + for (i = 0;i < count;i++) + { + strlcpy (out[i].name, in[i].name, sizeof (out[i].name)); + out[i].surfaceflags = LittleLong(in[i].surfaceflags); + out[i].supercontents = Mod_Q3BSP_SuperContentsFromNativeContents(loadmodel, LittleLong(in[i].contents)); + } - // parse the Q3 shader files - Mod_Q3BSP_LoadShaders(); + if (cls.state == ca_dedicated) + return; - c = 0; for (i = 0;i < count;i++, in++, out++) - { - q3shaderinfo_t *shader; - strlcpy (out->name, in->name, sizeof (out->name)); - out->surfaceflags = LittleLong(in->surfaceflags); - out->supercontents = Mod_Q3BSP_SuperContentsFromNativeContents(loadmodel, LittleLong(in->contents)); - shader = Mod_Q3BSP_LookupShader(out->name); - if (shader) - { - out->surfaceparms = shader->surfaceparms; - out->textureflags = shader->textureflags; - out->basematerialflags = 0; - if (shader->surfaceparms & Q3SURFACEPARM_SKY) - { - out->basematerialflags |= MATERIALFLAG_SKY | MATERIALFLAG_NOSHADOW; - if (shader->skyboxname[0]) - { - // quake3 seems to append a _ to the skybox name, so this must do so as well - dpsnprintf(loadmodel->brush.skybox, sizeof(loadmodel->brush.skybox), "%s_", shader->skyboxname); - } - } - else if ((out->surfaceflags & Q3SURFACEFLAG_NODRAW) || shader->numlayers == 0) - out->basematerialflags |= MATERIALFLAG_NODRAW | MATERIALFLAG_NOSHADOW; - else if (shader->surfaceparms & Q3SURFACEPARM_LAVA) - out->basematerialflags |= MATERIALFLAG_WATER | MATERIALFLAG_LIGHTBOTHSIDES | MATERIALFLAG_FULLBRIGHT | MATERIALFLAG_NOSHADOW; - else if (shader->surfaceparms & Q3SURFACEPARM_SLIME) - out->basematerialflags |= MATERIALFLAG_WATER | MATERIALFLAG_LIGHTBOTHSIDES | MATERIALFLAG_WATERALPHA | MATERIALFLAG_NOSHADOW; - else if (shader->surfaceparms & Q3SURFACEPARM_WATER) - out->basematerialflags |= MATERIALFLAG_WATER | MATERIALFLAG_LIGHTBOTHSIDES | MATERIALFLAG_WATERALPHA | MATERIALFLAG_NOSHADOW; - else - out->basematerialflags |= MATERIALFLAG_WALL; - if (shader->layers[0].alphatest) - out->basematerialflags |= MATERIALFLAG_ALPHATEST | MATERIALFLAG_TRANSPARENT | MATERIALFLAG_NOSHADOW; - if (shader->textureflags & (Q3TEXTUREFLAG_TWOSIDED | Q3TEXTUREFLAG_AUTOSPRITE | Q3TEXTUREFLAG_AUTOSPRITE2)) - out->basematerialflags |= MATERIALFLAG_NOSHADOW; - out->customblendfunc[0] = GL_ONE; - out->customblendfunc[1] = GL_ZERO; - if (shader->numlayers > 0) - { - out->customblendfunc[0] = shader->layers[0].blendfunc[0]; - out->customblendfunc[1] = shader->layers[0].blendfunc[1]; -/* -Q3 shader blendfuncs actually used in the game (* = supported by DP) -* additive GL_ONE GL_ONE - additive weird GL_ONE GL_SRC_ALPHA - additive weird 2 GL_ONE GL_ONE_MINUS_SRC_ALPHA -* alpha GL_SRC_ALPHA GL_ONE_MINUS_SRC_ALPHA - alpha inverse GL_ONE_MINUS_SRC_ALPHA GL_SRC_ALPHA - brighten GL_DST_COLOR GL_ONE - brighten GL_ONE GL_SRC_COLOR - brighten weird GL_DST_COLOR GL_ONE_MINUS_DST_ALPHA - brighten weird 2 GL_DST_COLOR GL_SRC_ALPHA -* modulate GL_DST_COLOR GL_ZERO -* modulate GL_ZERO GL_SRC_COLOR - modulate inverse GL_ZERO GL_ONE_MINUS_SRC_COLOR - modulate inverse alpha GL_ZERO GL_SRC_ALPHA - modulate weird inverse GL_ONE_MINUS_DST_COLOR GL_ZERO -* modulate x2 GL_DST_COLOR GL_SRC_COLOR -* no blend GL_ONE GL_ZERO - nothing GL_ZERO GL_ONE -*/ - // if not opaque, figure out what blendfunc to use - if (shader->layers[0].blendfunc[0] != GL_ONE || shader->layers[0].blendfunc[1] != GL_ZERO) - { - if (shader->layers[0].blendfunc[0] == GL_ONE && shader->layers[0].blendfunc[1] == GL_ONE) - out->basematerialflags |= MATERIALFLAG_ADD | MATERIALFLAG_BLENDED | MATERIALFLAG_TRANSPARENT | MATERIALFLAG_NOSHADOW; - else if (shader->layers[0].blendfunc[0] == GL_SRC_ALPHA && shader->layers[0].blendfunc[1] == GL_ONE) - out->basematerialflags |= MATERIALFLAG_ADD | MATERIALFLAG_BLENDED | MATERIALFLAG_TRANSPARENT | MATERIALFLAG_NOSHADOW; - else if (shader->layers[0].blendfunc[0] == GL_SRC_ALPHA && shader->layers[0].blendfunc[1] == GL_ONE_MINUS_SRC_ALPHA) - out->basematerialflags |= MATERIALFLAG_ALPHA | MATERIALFLAG_BLENDED | MATERIALFLAG_TRANSPARENT | MATERIALFLAG_NOSHADOW; - else - out->basematerialflags |= MATERIALFLAG_CUSTOMBLEND | MATERIALFLAG_FULLBRIGHT | MATERIALFLAG_BLENDED | MATERIALFLAG_TRANSPARENT | MATERIALFLAG_NOSHADOW; - } - } - if (!shader->lighting) - out->basematerialflags |= MATERIALFLAG_FULLBRIGHT; - if (shader->primarylayer && cls.state != ca_dedicated) - { - int j; - out->numskinframes = shader->primarylayer->numframes; - out->skinframerate = shader->primarylayer->framerate; - for (j = 0;j < shader->primarylayer->numframes;j++) - if (!Mod_LoadSkinFrame(&out->skinframes[j], shader->primarylayer->texturename[j], ((shader->surfaceparms & Q3SURFACEPARM_NOMIPMAPS) ? 0 : TEXF_MIPMAP) | TEXF_ALPHA | TEXF_PRECACHE | (shader->textureflags & Q3TEXTUREFLAG_NOPICMIP ? 0 : TEXF_PICMIP) | (shader->primarylayer->clampmap ? TEXF_CLAMP : 0), false, true)) - Con_Printf("%s: could not load texture \"%s\" (frame %i) for shader \"%s\"\n", loadmodel->name, shader->primarylayer->texturename[j], j, out->name); - } - if (shader->backgroundlayer && cls.state != ca_dedicated) - { - int j; - out->backgroundnumskinframes = shader->backgroundlayer->numframes; - out->backgroundskinframerate = shader->backgroundlayer->framerate; - for (j = 0;j < shader->backgroundlayer->numframes;j++) - if (!Mod_LoadSkinFrame(&out->backgroundskinframes[j], shader->backgroundlayer->texturename[j], ((shader->surfaceparms & Q3SURFACEPARM_NOMIPMAPS) ? 0 : TEXF_MIPMAP) | TEXF_ALPHA | TEXF_PRECACHE | (shader->textureflags & Q3TEXTUREFLAG_NOPICMIP ? 0 : TEXF_PICMIP) | (shader->backgroundlayer->clampmap ? TEXF_CLAMP : 0), false, true)) - Con_Printf("%s: could not load texture \"%s\" (frame %i) for shader \"%s\"\n", loadmodel->name, shader->backgroundlayer->texturename[j], j, out->name); - } - } - else if (!strcmp(out->name, "noshader")) - out->surfaceparms = 0; - else - { - c++; - Con_DPrintf("%s: No shader found for texture \"%s\"\n", loadmodel->name, out->name); - out->surfaceparms = 0; - if (out->surfaceflags & Q3SURFACEFLAG_NODRAW) - out->basematerialflags |= MATERIALFLAG_NODRAW | MATERIALFLAG_NOSHADOW; - else if (out->surfaceflags & Q3SURFACEFLAG_SKY) - out->basematerialflags |= MATERIALFLAG_SKY | MATERIALFLAG_NOSHADOW; - else - out->basematerialflags |= MATERIALFLAG_WALL; - // these are defaults - //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->skinframes[0].base)) - // out->surfaceparms |= Q3SURFACEPARM_TRANS; - if (cls.state != ca_dedicated) - if (!Mod_LoadSkinFrame(&out->skinframes[0], out->name, TEXF_MIPMAP | TEXF_ALPHA | TEXF_PRECACHE | TEXF_PICMIP, false, true)) - Con_Printf("%s: could not load texture for missing shader \"%s\"\n", loadmodel->name, out->name); - } - // init the animation variables - out->currentframe = out; - out->currentskinframe = &out->skinframes[0]; - out->backgroundcurrentskinframe = &out->backgroundskinframes[0]; - } - if (c) - Con_DPrintf("%s: %i textures missing shaders\n", loadmodel->name, c); + Mod_LoadTextureFromQ3Shader(out, out->name, true, true, TEXF_MIPMAP | TEXF_PRECACHE | (r_picmipworld.integer ? TEXF_PICMIP : 0) | TEXF_COMPRESS); } static void Mod_Q3BSP_LoadPlanes(lump_t *l) @@ -4624,6 +4281,34 @@ static void Mod_Q3BSP_LoadBrushSides(lump_t *l) } } +static void Mod_Q3BSP_LoadBrushSides_IG(lump_t *l) +{ + q3dbrushside_ig_t *in; + q3mbrushside_t *out; + int i, n, count; + + in = (q3dbrushside_ig_t *)(mod_base + l->fileofs); + if (l->filelen % sizeof(*in)) + Host_Error("Mod_Q3BSP_LoadBrushSides: funny lump size in %s",loadmodel->name); + count = l->filelen / sizeof(*in); + out = (q3mbrushside_t *)Mem_Alloc(loadmodel->mempool, count * sizeof(*out)); + + loadmodel->brush.data_brushsides = out; + loadmodel->brush.num_brushsides = count; + + for (i = 0;i < count;i++, in++, out++) + { + n = LittleLong(in->planeindex); + if (n < 0 || n >= loadmodel->brush.num_planes) + Host_Error("Mod_Q3BSP_LoadBrushSides: invalid planeindex %i (%i planes)", n, loadmodel->brush.num_planes); + out->plane = loadmodel->brush.data_planes + n; + n = LittleLong(in->textureindex); + if (n < 0 || n >= loadmodel->num_textures) + Host_Error("Mod_Q3BSP_LoadBrushSides: invalid textureindex %i (%i textures)", n, loadmodel->num_textures); + out->texture = loadmodel->data_textures + n; + } +} + static void Mod_Q3BSP_LoadBrushes(lump_t *l) { q3dbrush_t *in; @@ -4770,16 +4455,76 @@ static void Mod_Q3BSP_LoadTriangles(lump_t *l) static void Mod_Q3BSP_LoadLightmaps(lump_t *l, lump_t *faceslump) { - q3dlightmap_t *in; - int i, j, count, power, power2, mask, endlightmap; + q3dlightmap_t *input_pointer; + int i, j, k, count, power, power2, mask, endlightmap, mergewidth, mergeheight; unsigned char *c; - if (!l->filelen) + unsigned char *convertedpixels; + char mapname[MAX_QPATH]; + int size, bytesperpixel, rgbmap[3]; + qboolean external; + unsigned char *inpixels[10000]; // max count q3map2 can output (it uses 4 digits) + + // defaults for q3bsp + size = 128; + bytesperpixel = 3; + rgbmap[0] = 2; + rgbmap[1] = 1; + rgbmap[2] = 0; + external = false; + loadmodel->brushq3.lightmapsize = 128; + + if (cls.state == ca_dedicated) return; - in = (q3dlightmap_t *)(mod_base + l->fileofs); - if (l->filelen % sizeof(*in)) - Host_Error("Mod_Q3BSP_LoadLightmaps: funny lump size in %s",loadmodel->name); - count = l->filelen / sizeof(*in); + + FS_StripExtension(loadmodel->name, mapname, sizeof(mapname)); + inpixels[0] = loadimagepixelsbgra(va("%s/lm_%04d", mapname, 0), false, false); + if(inpixels[0]) + { + // using EXTERNAL lightmaps instead + if(image_width != (int) CeilPowerOf2(image_width) || image_width != image_height) + { + Mem_Free(inpixels[0]); + Host_Error("Mod_Q3BSP_LoadLightmaps: invalid external lightmap size in %s",loadmodel->name); + } + + size = image_width; + bytesperpixel = 4; + rgbmap[0] = 0; + rgbmap[1] = 1; + rgbmap[2] = 2; + external = true; + + for(count = 1; ; ++count) + { + inpixels[count] = loadimagepixelsbgra(va("%s/lm_%04d", mapname, count), false, false); + if(!inpixels[count]) + break; // we got all of them + if(image_width != size || image_height != size) + { + for(i = 0; i <= count; ++i) + Mem_Free(inpixels[i]); + Host_Error("Mod_Q3BSP_LoadLightmaps: invalid external lightmap size in %s",loadmodel->name); + } + } + } + else + { + if (!l->filelen) + { + return; + } + input_pointer = (q3dlightmap_t *)(mod_base + l->fileofs); + if (l->filelen % sizeof(*input_pointer)) + Host_Error("Mod_Q3BSP_LoadLightmaps: funny lump size in %s",loadmodel->name); + count = l->filelen / sizeof(*input_pointer); + for(i = 0; i < count; ++i) + inpixels[i] = input_pointer[i].rgb; + } + + convertedpixels = Mem_Alloc(tempmempool, size*size*4); // TODO free this + loadmodel->brushq3.lightmapsize = size; + loadmodel->brushq3.num_originallightmaps = count; // now check the surfaces to see if any of them index an odd numbered // lightmap, if so this is not a deluxemapped bsp file @@ -4811,20 +4556,27 @@ static void Mod_Q3BSP_LoadLightmaps(lump_t *l, lump_t *faceslump) } } } - if (endlightmap < 2) - loadmodel->brushq3.deluxemapping = false; // q3map2 sometimes (or always?) makes a second blank lightmap for no // reason when only one lightmap is used, which can throw off the // deluxemapping detection method, so check 2-lightmap bsp's specifically // to see if the second lightmap is blank, if so it is not deluxemapped. - if (endlightmap == 1 && count == 2) + // + // further research has shown q3map2 sometimes creates a deluxemap and two + // blank lightmaps, which must be handled properly as well + if (endlightmap == 1 && count > 1) { - c = in[1].rgb; - for (i = 0;i < 128*128*3;i++) - if (c[i]) + c = inpixels[1]; + for (i = 0;i < size*size;i++) + { + if (c[bytesperpixel*i + rgbmap[0]]) break; - if (i == 128*128*3) + if (c[bytesperpixel*i + rgbmap[1]]) + break; + if (c[bytesperpixel*i + rgbmap[2]]) + break; + } + if (i == size*size) { // all pixels in the unused lightmap were black... loadmodel->brushq3.deluxemapping = false; @@ -4835,34 +4587,85 @@ static void Mod_Q3BSP_LoadLightmaps(lump_t *l, lump_t *faceslump) // figure out what the most reasonable merge power is within limits loadmodel->brushq3.num_lightmapmergepower = 0; - for (power = 1;power <= mod_q3bsp_lightmapmergepower.integer && (1 << power) <= gl_max_texture_size && (1 << (power * 2)) < 4 * (count >> loadmodel->brushq3.deluxemapping);power++) + for (power = 1;power <= mod_q3bsp_lightmapmergepower.integer && (128 << power) <= gl_max_texture_size && (1 << (power * 2)) < 4 * (count >> loadmodel->brushq3.deluxemapping);power++) loadmodel->brushq3.num_lightmapmergepower = power; + + // as the lightmap size may actually be another power of 2, adjust for this + // (and interpret it as the power for 128x128 lightmaps above) + for(i = 0; (128 << i) < size; ++i) + loadmodel->brushq3.num_lightmapmergepower -= 1; + if(loadmodel->brushq3.num_lightmapmergepower < 0) + loadmodel->brushq3.num_lightmapmergepower = 0; + loadmodel->brushq3.num_lightmapmerge = 1 << loadmodel->brushq3.num_lightmapmergepower; - loadmodel->brushq3.num_lightmaps = ((count >> loadmodel->brushq3.deluxemapping) + (1 << (loadmodel->brushq3.num_lightmapmergepower * 2)) - 1) >> (loadmodel->brushq3.num_lightmapmergepower * 2); - loadmodel->brushq3.data_lightmaps = (rtexture_t **)Mem_Alloc(loadmodel->mempool, loadmodel->brushq3.num_lightmaps * sizeof(rtexture_t *)); + loadmodel->brushq3.num_mergedlightmaps = ((count >> loadmodel->brushq3.deluxemapping) + (1 << (loadmodel->brushq3.num_lightmapmergepower * 2)) - 1) >> (loadmodel->brushq3.num_lightmapmergepower * 2); + loadmodel->brushq3.data_lightmaps = (rtexture_t **)Mem_Alloc(loadmodel->mempool, loadmodel->brushq3.num_mergedlightmaps * sizeof(rtexture_t *)); if (loadmodel->brushq3.deluxemapping) - loadmodel->brushq3.data_deluxemaps = (rtexture_t **)Mem_Alloc(loadmodel->mempool, loadmodel->brushq3.num_lightmaps * sizeof(rtexture_t *)); - - j = 128 << loadmodel->brushq3.num_lightmapmergepower; - if (loadmodel->brushq3.data_lightmaps) - for (i = 0;i < loadmodel->brushq3.num_lightmaps;i++) - loadmodel->brushq3.data_lightmaps[i] = R_LoadTexture2D(loadmodel->texturepool, va("lightmap%04i", i), j, j, NULL, TEXTYPE_RGB, TEXF_FORCELINEAR | TEXF_PRECACHE, NULL); + loadmodel->brushq3.data_deluxemaps = (rtexture_t **)Mem_Alloc(loadmodel->mempool, loadmodel->brushq3.num_mergedlightmaps * sizeof(rtexture_t *)); - if (loadmodel->brushq3.data_deluxemaps) - for (i = 0;i < loadmodel->brushq3.num_lightmaps;i++) - loadmodel->brushq3.data_deluxemaps[i] = R_LoadTexture2D(loadmodel->texturepool, va("deluxemap%04i", i), j, j, NULL, TEXTYPE_RGB, TEXF_FORCELINEAR | TEXF_PRECACHE, NULL); + // allocate a texture pool if we need it + if (loadmodel->texturepool == NULL && cls.state != ca_dedicated) + loadmodel->texturepool = R_AllocTexturePool(); power = loadmodel->brushq3.num_lightmapmergepower; power2 = power * 2; mask = (1 << power) - 1; for (i = 0;i < count;i++) { - j = i >> loadmodel->brushq3.deluxemapping; - if (loadmodel->brushq3.deluxemapping && (i & 1)) - R_UpdateTexture(loadmodel->brushq3.data_deluxemaps[j >> power2], in[i].rgb, (j & mask) * 128, ((j >> power) & mask) * 128, 128, 128); + // figure out which merged lightmap texture this fits into + int lightmapindex = i >> (loadmodel->brushq3.deluxemapping + power2); + for (k = 0;k < size*size;k++) + { + convertedpixels[k*4+0] = inpixels[i][k*bytesperpixel+rgbmap[0]]; + convertedpixels[k*4+1] = inpixels[i][k*bytesperpixel+rgbmap[1]]; + convertedpixels[k*4+2] = inpixels[i][k*bytesperpixel+rgbmap[2]]; + convertedpixels[k*4+3] = 255; + } + if (loadmodel->brushq3.num_lightmapmergepower > 0) + { + // if the lightmap has not been allocated yet, create it + if (!loadmodel->brushq3.data_lightmaps[lightmapindex]) + { + // create a lightmap only as large as necessary to hold the + // remaining size*size blocks + // if there are multiple merged lightmap textures then they will + // all be full size except the last one which may be smaller + // because it only needs to the remaining blocks, and it will often + // be odd sizes like 2048x512 due to only being 25% full or so. + j = (count >> loadmodel->brushq3.deluxemapping) - (lightmapindex << power2); + for (mergewidth = 1;mergewidth < j && mergewidth < (1 << power);mergewidth *= 2) + ; + for (mergeheight = 1;mergewidth*mergeheight < j && mergeheight < (1 << power);mergeheight *= 2) + ; + if (developer_loading.integer) + Con_Printf("lightmap merge texture #%i is %ix%i (%i of %i used)\n", lightmapindex, mergewidth*size, mergeheight*size, min(j, mergewidth*mergeheight), mergewidth*mergeheight); + loadmodel->brushq3.data_lightmaps[lightmapindex] = R_LoadTexture2D(loadmodel->texturepool, va("lightmap%04i", lightmapindex), mergewidth * size, mergeheight * size, NULL, TEXTYPE_BGRA, TEXF_FORCELINEAR | TEXF_PRECACHE | (gl_texturecompression_q3bsplightmaps.integer ? TEXF_COMPRESS : 0), NULL); + if (loadmodel->brushq3.data_deluxemaps) + loadmodel->brushq3.data_deluxemaps[lightmapindex] = R_LoadTexture2D(loadmodel->texturepool, va("deluxemap%04i", lightmapindex), mergewidth * size, mergeheight * size, NULL, TEXTYPE_BGRA, TEXF_FORCELINEAR | TEXF_PRECACHE | (gl_texturecompression_q3bspdeluxemaps.integer ? TEXF_COMPRESS : 0), NULL); + } + mergewidth = R_TextureWidth(loadmodel->brushq3.data_lightmaps[lightmapindex]) / size; + mergeheight = R_TextureHeight(loadmodel->brushq3.data_lightmaps[lightmapindex]) / size; + j = (i >> loadmodel->brushq3.deluxemapping) & ((1 << power2) - 1); + if (loadmodel->brushq3.deluxemapping && (i & 1)) + R_UpdateTexture(loadmodel->brushq3.data_deluxemaps[lightmapindex], convertedpixels, (j % mergewidth) * size, (j / mergewidth) * size, size, size); + else + R_UpdateTexture(loadmodel->brushq3.data_lightmaps [lightmapindex], convertedpixels, (j % mergewidth) * size, (j / mergewidth) * size, size, size); + } else - R_UpdateTexture(loadmodel->brushq3.data_lightmaps [j >> power2], in[i].rgb, (j & mask) * 128, ((j >> power) & mask) * 128, 128, 128); + { + // figure out which merged lightmap texture this fits into + if (loadmodel->brushq3.deluxemapping && (i & 1)) + loadmodel->brushq3.data_deluxemaps[lightmapindex] = R_LoadTexture2D(loadmodel->texturepool, va("deluxemap%04i", lightmapindex), size, size, convertedpixels, TEXTYPE_BGRA, TEXF_FORCELINEAR | TEXF_PRECACHE | (gl_texturecompression_q3bspdeluxemaps.integer ? TEXF_COMPRESS : 0), NULL); + else + loadmodel->brushq3.data_lightmaps [lightmapindex] = R_LoadTexture2D(loadmodel->texturepool, va("lightmap%04i", lightmapindex), size, size, convertedpixels, TEXTYPE_BGRA, TEXF_FORCELINEAR | TEXF_PRECACHE | (gl_texturecompression_q3bsplightmaps.integer ? TEXF_COMPRESS : 0), NULL); + } + } + + if(external) + { + for(i = 0; i < count; ++i) + Mem_Free(inpixels[i]); } } @@ -4871,7 +4674,7 @@ static void Mod_Q3BSP_LoadFaces(lump_t *l) q3dface_t *in, *oldin; msurface_t *out, *oldout; int i, oldi, j, n, count, invalidelements, patchsize[2], finalwidth, finalheight, xtess, ytess, finalvertices, finaltriangles, firstvertex, firstelement, type, oldnumtriangles, oldnumtriangles2, meshvertices, meshtriangles, numvertices, numtriangles; - float lightmaptcbase[2], lightmaptcscale; + float lightmaptcbase[2], lightmaptcscale[2]; //int *originalelement3i; //int *originalneighbor3i; float *originalvertex3f; @@ -4902,7 +4705,7 @@ static void Mod_Q3BSP_LoadFaces(lump_t *l) { // check face type first type = LittleLong(in->type); - if (type != Q3FACETYPE_POLYGON + if (type != Q3FACETYPE_FLAT && type != Q3FACETYPE_PATCH && type != Q3FACETYPE_MESH && type != Q3FACETYPE_FLARE) @@ -4930,21 +4733,24 @@ static void Mod_Q3BSP_LoadFaces(lump_t *l) else out->effect = loadmodel->brushq3.data_effects + n; - out->lightmaptexture = NULL; - out->deluxemaptexture = r_texture_blanknormalmap; - n = LittleLong(in->lightmapindex); - if (n < 0) - n = -1; - else if (n >= (loadmodel->brushq3.num_lightmaps << (loadmodel->brushq3.num_lightmapmergepower * 2))) - { - 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 (cls.state != ca_dedicated) { - out->lightmaptexture = loadmodel->brushq3.data_lightmaps[n >> (loadmodel->brushq3.num_lightmapmergepower * 2 + loadmodel->brushq3.deluxemapping)]; - if (loadmodel->brushq3.deluxemapping) - out->deluxemaptexture = loadmodel->brushq3.data_deluxemaps[n >> (loadmodel->brushq3.num_lightmapmergepower * 2 + loadmodel->brushq3.deluxemapping)]; + out->lightmaptexture = NULL; + out->deluxemaptexture = r_texture_blanknormalmap; + n = LittleLong(in->lightmapindex); + if (n < 0) + n = -1; + else if (n >= loadmodel->brushq3.num_originallightmaps) + { + Con_Printf("Mod_Q3BSP_LoadFaces: face #%i (texture \"%s\"): invalid lightmapindex %i (%i lightmaps)\n", i, out->texture->name, n, loadmodel->brushq3.num_originallightmaps); + n = -1; + } + else + { + out->lightmaptexture = loadmodel->brushq3.data_lightmaps[n >> (loadmodel->brushq3.num_lightmapmergepower * 2 + loadmodel->brushq3.deluxemapping)]; + if (loadmodel->brushq3.deluxemapping) + out->deluxemaptexture = loadmodel->brushq3.data_deluxemaps[n >> (loadmodel->brushq3.num_lightmapmergepower * 2 + loadmodel->brushq3.deluxemapping)]; + } } firstvertex = LittleLong(in->firstvertex); @@ -4968,7 +4774,7 @@ static void Mod_Q3BSP_LoadFaces(lump_t *l) } switch(type) { - case Q3FACETYPE_POLYGON: + case Q3FACETYPE_FLAT: case Q3FACETYPE_MESH: // no processing necessary break; @@ -5033,7 +4839,7 @@ static void Mod_Q3BSP_LoadFaces(lump_t *l) out->num_firsttriangle = meshtriangles; switch(type) { - case Q3FACETYPE_POLYGON: + case Q3FACETYPE_FLAT: case Q3FACETYPE_MESH: // no processing necessary, except for lightmap merging for (j = 0;j < out->num_vertices;j++) @@ -5165,18 +4971,22 @@ static void Mod_Q3BSP_LoadFaces(lump_t *l) VectorClear(out->maxs); if (out->num_vertices) { - int lightmapindex = LittleLong(in->lightmapindex); - if (lightmapindex >= 0) + if (cls.state != ca_dedicated && out->lightmaptexture) { - lightmapindex >>= loadmodel->brushq3.deluxemapping; - lightmaptcscale = 1.0f / loadmodel->brushq3.num_lightmapmerge; - lightmaptcbase[0] = ((lightmapindex ) & (loadmodel->brushq3.num_lightmapmerge - 1)) * lightmaptcscale; - lightmaptcbase[1] = ((lightmapindex >> loadmodel->brushq3.num_lightmapmergepower) & (loadmodel->brushq3.num_lightmapmerge - 1)) * lightmaptcscale; + // figure out which part of the merged lightmap this fits into + int lightmapindex = LittleLong(in->lightmapindex) >> loadmodel->brushq3.deluxemapping; + int mergewidth = R_TextureWidth(out->lightmaptexture) / loadmodel->brushq3.lightmapsize; + int mergeheight = R_TextureHeight(out->lightmaptexture) / loadmodel->brushq3.lightmapsize; + lightmapindex &= mergewidth * mergeheight - 1; + lightmaptcscale[0] = 1.0f / mergewidth; + lightmaptcscale[1] = 1.0f / mergeheight; + lightmaptcbase[0] = (lightmapindex % mergewidth) * lightmaptcscale[0]; + lightmaptcbase[1] = (lightmapindex / mergewidth) * lightmaptcscale[1]; // modify the lightmap texcoords to match this region of the merged lightmap for (j = 0, v = loadmodel->surfmesh.data_texcoordlightmap2f + 2 * out->num_firstvertex;j < out->num_vertices;j++, v += 2) { - v[0] = v[0] * lightmaptcscale + lightmaptcbase[0]; - v[1] = v[1] * lightmaptcscale + lightmaptcbase[1]; + v[0] = v[0] * lightmaptcscale[0] + lightmaptcbase[0]; + v[1] = v[1] * lightmaptcscale[1] + lightmaptcbase[1]; } } VectorCopy((loadmodel->surfmesh.data_vertex3f + 3 * out->num_firstvertex), out->mins); @@ -5207,6 +5017,11 @@ static void Mod_Q3BSP_LoadFaces(lump_t *l) // for per pixel lighting Mod_BuildTextureVectorsFromNormals(0, loadmodel->surfmesh.num_vertices, loadmodel->surfmesh.num_triangles, loadmodel->surfmesh.data_vertex3f, loadmodel->surfmesh.data_texcoordtexture2f, loadmodel->surfmesh.data_normal3f, loadmodel->surfmesh.data_element3i, loadmodel->surfmesh.data_svector3f, loadmodel->surfmesh.data_tvector3f, true); + // generate ushort elements array if possible + if (loadmodel->surfmesh.data_element3s) + for (i = 0;i < loadmodel->surfmesh.num_triangles*3;i++) + loadmodel->surfmesh.data_element3s[i] = loadmodel->surfmesh.data_element3i[i]; + // free the no longer needed vertex data loadmodel->brushq3.num_vertices = 0; if (loadmodel->brushq3.data_vertex3f) @@ -5479,14 +5294,14 @@ static void Mod_Q3BSP_LoadPVS(lump_t *l) memcpy(loadmodel->brush.data_pvsclusters, (unsigned char *)(in + 1), totalchains); } -static void Mod_Q3BSP_LightPoint(model_t *model, const vec3_t p, vec3_t ambientcolor, vec3_t diffusecolor, vec3_t diffusenormal) +static void Mod_Q3BSP_LightPoint(dp_model_t *model, const vec3_t p, vec3_t ambientcolor, vec3_t diffusecolor, vec3_t diffusenormal) { int i, j, k, index[3]; - float transformed[3], blend1, blend2, blend, yaw, pitch, sinpitch, stylescale; + float transformed[3], blend1, blend2, blend, stylescale; q3dlightgrid_t *a, *s; // scale lighting by lightstyle[0] so that darkmode in dpmod works properly - stylescale = r_refdef.lightstylevalue[0] * (1.0f / 264.0f); + stylescale = r_refdef.scene.rtlightstylevalue[0]; if (!model->brushq3.num_lightgrid) { @@ -5528,12 +5343,12 @@ static void Mod_Q3BSP_LightPoint(model_t *model, const vec3_t p, vec3_t ambientc s = a + (k * model->brushq3.num_lightgrid_isize[1] + j) * model->brushq3.num_lightgrid_isize[0] + i; VectorMA(ambientcolor, blend * (1.0f / 128.0f), s->ambientrgb, ambientcolor); VectorMA(diffusecolor, blend * (1.0f / 128.0f), s->diffusergb, diffusecolor); - pitch = s->diffusepitch * M_PI / 128; - yaw = s->diffuseyaw * M_PI / 128; - sinpitch = sin(pitch); - diffusenormal[0] += blend * (cos(yaw) * sinpitch); - diffusenormal[1] += blend * (sin(yaw) * sinpitch); - diffusenormal[2] += blend * (cos(pitch)); + // this uses the mod_md3_sin table because the values are + // already in the 0-255 range, the 64+ bias fetches a cosine + // instead of a sine value + diffusenormal[0] += blend * (mod_md3_sin[64 + s->diffuseyaw] * mod_md3_sin[s->diffusepitch]); + diffusenormal[1] += blend * (mod_md3_sin[ s->diffuseyaw] * mod_md3_sin[s->diffusepitch]); + diffusenormal[2] += blend * (mod_md3_sin[64 + s->diffusepitch]); //Con_Printf("blend %f: ambient %i %i %i, diffuse %i %i %i, diffusepitch %i diffuseyaw %i (%f %f, normal %f %f %f)\n", blend, s->ambientrgb[0], s->ambientrgb[1], s->ambientrgb[2], s->diffusergb[0], s->diffusergb[1], s->diffusergb[2], s->diffusepitch, s->diffuseyaw, pitch, yaw, (cos(yaw) * cospitch), (sin(yaw) * cospitch), (-sin(pitch))); } } @@ -5544,14 +5359,14 @@ static void Mod_Q3BSP_LightPoint(model_t *model, const vec3_t p, vec3_t ambientc //Con_Printf("result: ambient %f %f %f diffuse %f %f %f diffusenormal %f %f %f\n", ambientcolor[0], ambientcolor[1], ambientcolor[2], diffusecolor[0], diffusecolor[1], diffusecolor[2], diffusenormal[0], diffusenormal[1], diffusenormal[2]); } -static void Mod_Q3BSP_TracePoint_RecursiveBSPNode(trace_t *trace, model_t *model, mnode_t *node, const vec3_t point, int markframe) +static void Mod_Q3BSP_TracePoint_RecursiveBSPNode(trace_t *trace, dp_model_t *model, mnode_t *node, const vec3_t point, int markframe) { int i; mleaf_t *leaf; colbrushf_t *brush; // find which leaf the point is in while (node->plane) - node = node->children[DotProduct(point, node->plane->normal) < node->plane->dist]; + node = node->children[(node->plane->type < 3 ? point[node->plane->type] : DotProduct(point, node->plane->normal)) < node->plane->dist]; // point trace the brushes leaf = (mleaf_t *)node; for (i = 0;i < leaf->numleafbrushes;i++) @@ -5566,7 +5381,7 @@ static void Mod_Q3BSP_TracePoint_RecursiveBSPNode(trace_t *trace, model_t *model // can't do point traces on curves (they have no thickness) } -static void Mod_Q3BSP_TraceLine_RecursiveBSPNode(trace_t *trace, model_t *model, mnode_t *node, const vec3_t start, const vec3_t end, vec_t startfrac, vec_t endfrac, const vec3_t linestart, const vec3_t lineend, int markframe, const vec3_t segmentmins, const vec3_t segmentmaxs) +static void Mod_Q3BSP_TraceLine_RecursiveBSPNode(trace_t *trace, dp_model_t *model, mnode_t *node, const vec3_t start, const vec3_t end, vec_t startfrac, vec_t endfrac, const vec3_t linestart, const vec3_t lineend, int markframe, const vec3_t segmentmins, const vec3_t segmentmaxs) { int i, startside, endside; float dist1, dist2, midfrac, mid[3], nodesegmentmins[3], nodesegmentmaxs[3]; @@ -5653,7 +5468,7 @@ static void Mod_Q3BSP_TraceLine_RecursiveBSPNode(trace_t *trace, model_t *model, } } -static void Mod_Q3BSP_TraceBrush_RecursiveBSPNode(trace_t *trace, model_t *model, mnode_t *node, const colbrushf_t *thisbrush_start, const colbrushf_t *thisbrush_end, int markframe, const vec3_t segmentmins, const vec3_t segmentmaxs) +static void Mod_Q3BSP_TraceBrush_RecursiveBSPNode(trace_t *trace, dp_model_t *model, mnode_t *node, const colbrushf_t *thisbrush_start, const colbrushf_t *thisbrush_end, int markframe, const vec3_t segmentmins, const vec3_t segmentmaxs) { int i; int sides; @@ -5734,7 +5549,7 @@ static void Mod_Q3BSP_TraceBrush_RecursiveBSPNode(trace_t *trace, model_t *model } } -static void Mod_Q3BSP_TraceBox(model_t *model, int frame, trace_t *trace, const vec3_t start, const vec3_t boxmins, const vec3_t boxmaxs, const vec3_t end, int hitsupercontentsmask) +static void Mod_Q3BSP_TraceBox(dp_model_t *model, int frame, trace_t *trace, const vec3_t start, const vec3_t boxmins, const vec3_t boxmaxs, const vec3_t end, int hitsupercontentsmask) { int i; float segmentmins[3], segmentmaxs[3]; @@ -5814,7 +5629,39 @@ static void Mod_Q3BSP_TraceBox(model_t *model, int frame, trace_t *trace, const } } -static int Mod_Q3BSP_SuperContentsFromNativeContents(model_t *model, int nativecontents) +static int Mod_Q3BSP_PointSuperContents(struct model_s *model, int frame, const vec3_t point) +{ + int i; + int supercontents = 0; + q3mbrush_t *brush; + // test if the point is inside each brush + if (model->brush.submodel) + { + // submodels are effectively one leaf + for (i = 0, brush = model->brush.data_brushes + model->firstmodelbrush;i < model->nummodelbrushes;i++, brush++) + if (brush->colbrushf && Collision_PointInsideBrushFloat(point, brush->colbrushf)) + supercontents |= brush->colbrushf->supercontents; + } + else + { + mnode_t *node = model->brush.data_nodes; + mleaf_t *leaf; + // find which leaf the point is in + while (node->plane) + node = node->children[(node->plane->type < 3 ? point[node->plane->type] : DotProduct(point, node->plane->normal)) < node->plane->dist]; + leaf = (mleaf_t *)node; + // now check the brushes in the leaf + for (i = 0;i < leaf->numleafbrushes;i++) + { + brush = model->brush.data_brushes + leaf->firstleafbrush[i]; + if (brush->colbrushf && Collision_PointInsideBrushFloat(point, brush->colbrushf)) + supercontents |= brush->colbrushf->supercontents; + } + } + return supercontents; +} + +static int Mod_Q3BSP_SuperContentsFromNativeContents(dp_model_t *model, int nativecontents) { int supercontents = 0; if (nativecontents & CONTENTSQ3_SOLID) @@ -5840,7 +5687,7 @@ static int Mod_Q3BSP_SuperContentsFromNativeContents(model_t *model, int nativec return supercontents; } -static int Mod_Q3BSP_NativeContentsFromSuperContents(model_t *model, int supercontents) +static int Mod_Q3BSP_NativeContentsFromSuperContents(dp_model_t *model, int supercontents) { int nativecontents = 0; if (supercontents & SUPERCONTENTS_SOLID) @@ -5879,13 +5726,15 @@ void Mod_Q3BSP_RecursiveFindNumLeafs(mnode_t *node) loadmodel->brush.num_leafs = numleafs; } -void Mod_Q3BSP_Load(model_t *mod, void *buffer, void *bufferend) +void Mod_Q3BSP_Load(dp_model_t *mod, void *buffer, void *bufferend) { - int i, j, numshadowmeshtriangles; + int i, j, numshadowmeshtriangles, lumps; q3dheader_t *header; float corner[3], yawradius, modelradius; msurface_t *surface; + mod->modeldatatypestring = "Q3BSP"; + mod->type = mod_brushq3; mod->numframes = 2; // although alternate textures are not supported it is annoying to complain about no such frame 1 mod->numskins = 1; @@ -5893,18 +5742,15 @@ void Mod_Q3BSP_Load(model_t *mod, void *buffer, void *bufferend) header = (q3dheader_t *)buffer; i = LittleLong(header->version); - if (i != Q3BSPVERSION) + if (i != Q3BSPVERSION && i != Q3BSPVERSION_IG && i != Q3BSPVERSION_LIVE) Host_Error("Mod_Q3BSP_Load: %s has wrong version number (%i, should be %i)", mod->name, i, Q3BSPVERSION); mod->brush.ishlbsp = false; - mod->brush.ismcbsp = false; if (loadmodel->isworldmodel) - { Cvar_SetValue("halflifebsp", mod->brush.ishlbsp); - Cvar_SetValue("mcbsp", mod->brush.ismcbsp); - } mod->soundfromcenter = true; mod->TraceBox = Mod_Q3BSP_TraceBox; + mod->PointSuperContents = Mod_Q3BSP_PointSuperContents; mod->brush.TraceLineOfSight = Mod_Q1BSP_TraceLineOfSight; mod->brush.SuperContentsFromNativeContents = Mod_Q3BSP_SuperContentsFromNativeContents; mod->brush.NativeContentsFromSuperContents = Mod_Q3BSP_NativeContentsFromSuperContents; @@ -5918,25 +5764,34 @@ void Mod_Q3BSP_Load(model_t *mod, void *buffer, void *bufferend) mod->brush.FindNonSolidLocation = Mod_Q1BSP_FindNonSolidLocation; mod->brush.PointInLeaf = Mod_Q1BSP_PointInLeaf; mod->Draw = R_Q1BSP_Draw; + mod->DrawDepth = R_Q1BSP_DrawDepth; + mod->DrawDebug = R_Q1BSP_DrawDebug; mod->GetLightInfo = R_Q1BSP_GetLightInfo; mod->CompileShadowVolume = R_Q1BSP_CompileShadowVolume; mod->DrawShadowVolume = R_Q1BSP_DrawShadowVolume; mod->DrawLight = R_Q1BSP_DrawLight; + mod->DrawAddWaterPlanes = NULL; mod_base = (unsigned char *)header; // swap all the lumps header->ident = LittleLong(header->ident); header->version = LittleLong(header->version); - for (i = 0;i < Q3HEADER_LUMPS;i++) + lumps = (header->version == Q3BSPVERSION_LIVE) ? Q3HEADER_LUMPS_LIVE : Q3HEADER_LUMPS; + for (i = 0;i < lumps;i++) { header->lumps[i].fileofs = LittleLong(header->lumps[i].fileofs); header->lumps[i].filelen = LittleLong(header->lumps[i].filelen); } + for (i = lumps;i < Q3HEADER_LUMPS_MAX;i++) + { + header->lumps[i].fileofs = 0; + header->lumps[i].filelen = 0; + } mod->brush.qw_md4sum = 0; mod->brush.qw_md4sum2 = 0; - for (i = 0;i < Q3HEADER_LUMPS;i++) + for (i = 0;i < lumps;i++) { if (i == Q3LUMP_ENTITIES) continue; @@ -5949,7 +5804,10 @@ void Mod_Q3BSP_Load(model_t *mod, void *buffer, void *bufferend) Mod_Q3BSP_LoadEntities(&header->lumps[Q3LUMP_ENTITIES]); Mod_Q3BSP_LoadTextures(&header->lumps[Q3LUMP_TEXTURES]); Mod_Q3BSP_LoadPlanes(&header->lumps[Q3LUMP_PLANES]); - Mod_Q3BSP_LoadBrushSides(&header->lumps[Q3LUMP_BRUSHSIDES]); + if (header->version == Q3BSPVERSION_IG) + Mod_Q3BSP_LoadBrushSides_IG(&header->lumps[Q3LUMP_BRUSHSIDES]); + else + Mod_Q3BSP_LoadBrushSides(&header->lumps[Q3LUMP_BRUSHSIDES]); Mod_Q3BSP_LoadBrushes(&header->lumps[Q3LUMP_BRUSHES]); Mod_Q3BSP_LoadEffects(&header->lumps[Q3LUMP_EFFECTS]); Mod_Q3BSP_LoadVertices(&header->lumps[Q3LUMP_VERTICES]); @@ -5982,20 +5840,12 @@ void Mod_Q3BSP_Load(model_t *mod, void *buffer, void *bufferend) for (j = 0, surface = loadmodel->data_surfaces;j < loadmodel->num_surfaces;j++, surface++) if (surface->num_triangles > 0) Mod_ShadowMesh_AddMesh(loadmodel->mempool, loadmodel->brush.shadowmesh, NULL, NULL, NULL, loadmodel->surfmesh.data_vertex3f, NULL, NULL, NULL, NULL, surface->num_triangles, (loadmodel->surfmesh.data_element3i + 3 * surface->num_firsttriangle)); - loadmodel->brush.shadowmesh = Mod_ShadowMesh_Finish(loadmodel->mempool, loadmodel->brush.shadowmesh, false, true); + loadmodel->brush.shadowmesh = Mod_ShadowMesh_Finish(loadmodel->mempool, loadmodel->brush.shadowmesh, false, true, false); Mod_BuildTriangleNeighbors(loadmodel->brush.shadowmesh->neighbor3i, loadmodel->brush.shadowmesh->element3i, loadmodel->brush.shadowmesh->numtriangles); loadmodel->brush.num_leafs = 0; Mod_Q3BSP_RecursiveFindNumLeafs(loadmodel->brush.data_nodes); - if (loadmodel->isworldmodel) - { - // clear out any stale submodels or worldmodels lying around - // if we did this clear before now, an error might abort loading and - // leave things in a bad state - Mod_RemoveStaleWorldModels(loadmodel); - } - mod = loadmodel; for (i = 0;i < loadmodel->brush.numsubmodels;i++) { @@ -6008,7 +5858,7 @@ void Mod_Q3BSP_Load(model_t *mod, void *buffer, void *bufferend) if (!loadmodel->isworldmodel) continue; // duplicate the basic information - sprintf(name, "*%i", i); + dpsnprintf(name, sizeof(name), "*%i", i); mod = Mod_FindName(name); *mod = *loadmodel; strlcpy(mod->name, name, sizeof(mod->name)); @@ -6038,6 +5888,30 @@ void Mod_Q3BSP_Load(model_t *mod, void *buffer, void *bufferend) VectorCopy(mod->brushq3.data_models[i].mins, mod->normalmins); VectorCopy(mod->brushq3.data_models[i].maxs, mod->normalmaxs); + // enlarge the bounding box to enclose all geometry of this model, + // because q3map2 sometimes lies (mostly to affect the lightgrid), + // which can in turn mess up the farclip (as well as culling when + // outside the level - an unimportant concern) + + //printf("Editing model %d... BEFORE re-bounding: %f %f %f - %f %f %f\n", i, mod->normalmins[0], mod->normalmins[1], mod->normalmins[2], mod->normalmaxs[0], mod->normalmaxs[1], mod->normalmaxs[2]); + for (j = 0;j < mod->nummodelsurfaces;j++) + { + const msurface_t *surface = mod->data_surfaces + j + mod->firstmodelsurface; + const float *v = mod->surfmesh.data_vertex3f + 3 * surface->num_firstvertex; + int k; + if (!surface->num_vertices) + continue; + for (k = 0;k < surface->num_vertices;k++, v += 3) + { + mod->normalmins[0] = min(mod->normalmins[0], v[0]); + mod->normalmins[1] = min(mod->normalmins[1], v[1]); + mod->normalmins[2] = min(mod->normalmins[2], v[2]); + mod->normalmaxs[0] = max(mod->normalmaxs[0], v[0]); + mod->normalmaxs[1] = max(mod->normalmaxs[1], v[1]); + mod->normalmaxs[2] = max(mod->normalmaxs[2], v[2]); + } + } + //printf("Editing model %d... AFTER re-bounding: %f %f %f - %f %f %f\n", i, mod->normalmins[0], mod->normalmins[1], mod->normalmins[2], mod->normalmaxs[0], mod->normalmaxs[1], mod->normalmaxs[2]); corner[0] = max(fabs(mod->normalmins[0]), fabs(mod->normalmaxs[0])); corner[1] = max(fabs(mod->normalmins[1]), fabs(mod->normalmaxs[1])); corner[2] = max(fabs(mod->normalmins[2]), fabs(mod->normalmaxs[2])); @@ -6053,19 +5927,27 @@ void Mod_Q3BSP_Load(model_t *mod, void *buffer, void *bufferend) mod->radius2 = modelradius * modelradius; for (j = 0;j < mod->nummodelsurfaces;j++) - if (mod->data_surfaces[j + mod->firstmodelsurface].texture->surfaceflags & Q3SURFACEFLAG_SKY) + if (mod->data_surfaces[j + mod->firstmodelsurface].texture->basematerialflags & MATERIALFLAG_SKY) break; if (j < mod->nummodelsurfaces) mod->DrawSky = R_Q1BSP_DrawSky; else mod->DrawSky = NULL; + + for (j = 0;j < mod->nummodelsurfaces;j++) + if (mod->data_surfaces[j + mod->firstmodelsurface].texture->basematerialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION | MATERIALFLAG_REFLECTION)) + break; + if (j < mod->nummodelsurfaces) + mod->DrawAddWaterPlanes = R_Q1BSP_DrawAddWaterPlanes; + else + mod->DrawAddWaterPlanes = NULL; } } -void Mod_IBSP_Load(model_t *mod, void *buffer, void *bufferend) +void Mod_IBSP_Load(dp_model_t *mod, void *buffer, void *bufferend) { int i = LittleLong(((int *)buffer)[1]); - if (i == Q3BSPVERSION) + if (i == Q3BSPVERSION || i == Q3BSPVERSION_IG || i == Q3BSPVERSION_LIVE) Mod_Q3BSP_Load(mod,buffer, bufferend); else if (i == Q2BSPVERSION) Mod_Q2BSP_Load(mod,buffer, bufferend); @@ -6073,8 +5955,44 @@ void Mod_IBSP_Load(model_t *mod, void *buffer, void *bufferend) Host_Error("Mod_IBSP_Load: unknown/unsupported version %i", i); } -void Mod_MAP_Load(model_t *mod, void *buffer, void *bufferend) +void Mod_MAP_Load(dp_model_t *mod, void *buffer, void *bufferend) { Host_Error("Mod_MAP_Load: not yet implemented"); } +qboolean Mod_CanSeeBox_Trace(int numsamples, float t, dp_model_t *model, vec3_t eye, vec3_t minsX, vec3_t maxsX) +{ + // we already have done PVS culling at this point... + // so we don't need to do it again. + + int i; + vec3_t testorigin, mins, maxs; + + testorigin[0] = (minsX[0] + maxsX[0]) * 0.5; + testorigin[1] = (minsX[1] + maxsX[1]) * 0.5; + testorigin[2] = (minsX[2] + maxsX[2]) * 0.5; + + if(model->brush.TraceLineOfSight(model, eye, testorigin)) + return 1; + + // expand the box a little + mins[0] = (t+1) * minsX[0] - t * maxsX[0]; + maxs[0] = (t+1) * maxsX[0] - t * minsX[0]; + mins[1] = (t+1) * minsX[1] - t * maxsX[1]; + maxs[1] = (t+1) * maxsX[1] - t * minsX[1]; + mins[2] = (t+1) * minsX[2] - t * maxsX[2]; + maxs[2] = (t+1) * maxsX[2] - t * minsX[2]; + + for(i = 0; i != numsamples; ++i) + { + testorigin[0] = lhrandom(mins[0], maxs[0]); + testorigin[1] = lhrandom(mins[1], maxs[1]); + testorigin[2] = lhrandom(mins[2], maxs[2]); + + if(model->brush.TraceLineOfSight(model, eye, testorigin)) + return 1; + } + + return 0; +} +