//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)"};
{
// 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);
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;
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;
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;
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];
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];
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];
vec_t radius;
vec3_t nudge;
vec_t bestdist;
- model_t *model;
+ dp_model_t *model;
}
findnonsolidlocationinfo_t;
}
}
-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;
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)
{
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;
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];
//#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)
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
#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
#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));
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;
// 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++)
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
}
}
}
}
-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)
{
// pretend lighting is coming down from above (due to lack of a lightgrid to know primary lighting direction)
VectorSet(diffusenormal, 0, 0, 1);
if (loadmodel->texturepool == NULL && cls.state != ca_dedicated)
loadmodel->texturepool = R_AllocTexturePool();
- // if sky isn't the right size, just use it as a solid layer
- if (width != 256 || height != 128)
- {
- loadmodel->brush.solidskytexture = R_LoadTexture2D(loadmodel->texturepool, "sky_solidtexture", width, height, src, bytesperpixel == 4 ? TEXTYPE_RGBA : TEXTYPE_PALETTE, TEXF_PRECACHE, bytesperpixel == 1 ? palette_complete : NULL);
- loadmodel->brush.alphaskytexture = NULL;
- return;
- }
-
if (bytesperpixel == 4)
{
for (i = 0;i < 128;i++)
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)
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;
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
- skinframe = R_SkinFrame_LoadMissing();
+ 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->skinframes[0] = skinframe;
- tx->currentskinframe = tx->skinframes[0];
- 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))
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;
// 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)
{
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);
}
else
{
- skinframe = R_SkinFrame_LoadExternal(gamemode == GAME_TENEBRAE ? tx->name : va("textures/%s/%s", mapname, tx->name), TEXF_MIPMAP | TEXF_ALPHA | TEXF_PRECACHE | TEXF_PICMIP);
+ 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_ALPHA | TEXF_PRECACHE | TEXF_PICMIP);
+ 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
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;
- skinframe = R_SkinFrame_LoadInternal(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
- skinframe = R_SkinFrame_LoadInternal(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;
}
- }
- 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_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;
- tx->currentskinframe = tx->skinframes[0];
+ // start out with no animation
+ tx->currentframe = tx;
+ tx->currentskinframe = tx->skinframes[0];
+ }
}
// sequence the animations
for (i=0; i<l->filelen; 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
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);
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;
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
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
{
// 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
}
#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 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 rowY;
+ int currentX;
+};
+
+struct alloc_lm_state
+{
+ 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))
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;
}
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;
// 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);
{
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;
// 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 && cls.state != ca_dedicated)
+ 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++)
{
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)
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;
+ }
+ }
}
}
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;
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++)
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;
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;
for (i=0 ; i<count ; i++, out++, in++)
{
out->planenum = 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)");
}
}
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;
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;
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
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
}
for (;;)
{
- if (!COM_ParseTokenConsole(&data))
+ if (!COM_ParseToken_Simple(&data, false, false))
return; // error
if (com_token[0] == '}')
break; // end of brush
// 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);
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;
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)
{
//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);
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
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;
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;
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++)
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:
// 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
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;
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;
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++)
// 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;
}
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
{
*/
}
-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;
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;
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++)
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)
{
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
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);
}
}
}
-// 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->backgroundlayer = NULL;
- shader->primarylayer = shader->layers + 0;
- if ((shader->layers[0].blendfunc[0] == GL_ONE && shader->layers[0].blendfunc[1] == GL_ZERO && !shader->layers[0].alphatest)
- && ((shader->layers[1].blendfunc[0] == GL_SRC_ALPHA && shader->layers[1].blendfunc[1] == GL_ONE_MINUS_SRC_ALPHA && !shader->layers[0].alphatest)
- || (shader->layers[1].blendfunc[0] == GL_ONE && shader->layers[1].blendfunc[1] == GL_ZERO && 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->backgroundlayer = NULL;
- 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))
loadmodel->data_textures = out;
loadmodel->num_textures = count;
+ loadmodel->num_texturesperskin = loadmodel->num_textures;
- // parse the Q3 shader files
- Mod_Q3BSP_LoadShaders();
+ 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));
+ }
+
+ 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_NOSHADOW;
- if (shader->textureflags & Q3TEXTUREFLAG_TWOSIDED)
- out->basematerialflags |= MATERIALFLAG_NOSHADOW | MATERIALFLAG_NOCULLFACE;
- if (shader->textureflags & (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_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_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_NOSHADOW;
- else
- out->basematerialflags |= MATERIALFLAG_CUSTOMBLEND | MATERIALFLAG_FULLBRIGHT | MATERIALFLAG_BLENDED | 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 (!(out->skinframes[j] = R_SkinFrame_LoadExternal(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))))
- Con_DPrintf("%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 (!(out->backgroundskinframes[j] = R_SkinFrame_LoadExternal(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))))
- {
- Con_DPrintf("%s: could not load texture \"%s\" (frame %i) for shader \"%s\"\n", loadmodel->name, shader->backgroundlayer->texturename[j], j, out->name);
- out->backgroundskinframes[j] = R_SkinFrame_LoadMissing();
- }
- }
- }
- }
- 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 (!(out->skinframes[0] = R_SkinFrame_LoadExternal(out->name, TEXF_MIPMAP | TEXF_ALPHA | TEXF_PRECACHE | TEXF_PICMIP)))
- Con_DPrintf("%s: could not load texture for missing shader \"%s\"\n", loadmodel->name, out->name);
- }
- // init the animation variables
- out->currentframe = out;
- if (!out->skinframes[0])
- out->skinframes[0] = R_SkinFrame_LoadMissing();
- 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)
}
}
+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;
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)
- return;
+ 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
}
}
}
- 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 (c[bytesperpixel*i + rgbmap[1]])
+ break;
+ if (c[bytesperpixel*i + rgbmap[2]])
break;
- if (i == 128*128*3)
+ }
+ if (i == size*size)
{
// all pixels in the unused lightmap were black...
loadmodel->brushq3.deluxemapping = false;
// 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_mergedlightmaps = ((count >> loadmodel->brushq3.deluxemapping) + (1 << (loadmodel->brushq3.num_lightmapmergepower * 2)) - 1) >> (loadmodel->brushq3.num_lightmapmergepower * 2);
if (loadmodel->texturepool == NULL && cls.state != ca_dedicated)
loadmodel->texturepool = R_AllocTexturePool();
- j = 128 << loadmodel->brushq3.num_lightmapmergepower;
- if (loadmodel->brushq3.data_lightmaps)
- for (i = 0;i < loadmodel->brushq3.num_mergedlightmaps;i++)
- loadmodel->brushq3.data_lightmaps[i] = R_LoadTexture2D(loadmodel->texturepool, va("lightmap%04i", i), j, j, NULL, TEXTYPE_RGB, TEXF_FORCELINEAR | TEXF_PRECACHE, NULL);
-
- if (loadmodel->brushq3.data_deluxemaps)
- for (i = 0;i < loadmodel->brushq3.num_mergedlightmaps;i++)
- loadmodel->brushq3.data_deluxemaps[i] = R_LoadTexture2D(loadmodel->texturepool, va("deluxemap%04i", i), j, j, NULL, TEXTYPE_RGB, TEXF_FORCELINEAR | TEXF_PRECACHE, NULL);
-
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]);
}
}
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;
{
// 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)
}
switch(type)
{
- case Q3FACETYPE_POLYGON:
+ case Q3FACETYPE_FLAT:
case Q3FACETYPE_MESH:
// no processing necessary
break;
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++)
VectorClear(out->maxs);
if (out->num_vertices)
{
- int lightmapindex = LittleLong(in->lightmapindex);
- if (lightmapindex >= 0 && cls.state != ca_dedicated)
+ 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);
// 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)
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)
{
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)));
}
}
//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++)
// 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];
}
}
-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;
}
}
-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];
}
}
-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)
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)
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;
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;
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;
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]);
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++)
{
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));
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]));
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);
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, model_t *model, vec3_t eye, vec3_t minsX, vec3_t maxsX)
+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.
projects / xonotic / darkplaces.git / blobdiff