X-Git-Url: http://de.git.xonotic.org/?p=xonotic%2Fdarkplaces.git;a=blobdiff_plain;f=model_brush.c;h=7af9d0e7b4a225a7fc75eb93601d21ff65122082;hp=ebcd7bf1cc40995351e277e4e6dfa9465ae8ad87;hb=947a3490696c20875ce9e191cf8dbc5a3b45d0f8;hpb=01d7518ef25649f2eb560668499f7d9934b2e91c diff --git a/model_brush.c b/model_brush.c index ebcd7bf1..7af9d0e7 100644 --- a/model_brush.c +++ b/model_brush.c @@ -27,24 +27,25 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. //cvar_t r_subdivide_size = {CVAR_SAVE, "r_subdivide_size", "128", "how large water polygons should be (smaller values produce more polygons which give better warping effects)"}; -cvar_t halflifebsp = {0, "halflifebsp", "0", "indicates the current map is hlbsp format (useful to know because of different bounding box sizes)"}; -cvar_t mcbsp = {0, "mcbsp", "0", "indicates the current map is mcbsp format (useful to know because of different bounding box sizes)"}; cvar_t r_novis = {0, "r_novis", "0", "draws whole level, see also sv_cullentities_pvs 0"}; -cvar_t r_lightmaprgba = {0, "r_lightmaprgba", "1", "whether to use RGBA (32bit) or RGB (24bit) lightmaps"}; cvar_t r_picmipworld = {CVAR_SAVE, "r_picmipworld", "1", "whether gl_picmip shall apply to world textures too"}; cvar_t r_nosurftextures = {0, "r_nosurftextures", "0", "pretends there was no texture lump found in the q1bsp/hlbsp loading (useful for debugging this rare case)"}; cvar_t r_subdivisions_tolerance = {0, "r_subdivisions_tolerance", "4", "maximum error tolerance on curve subdivision for rendering purposes (in other words, the curves will be given as many polygons as necessary to represent curves at this quality)"}; -cvar_t r_subdivisions_mintess = {0, "r_subdivisions_mintess", "1", "minimum number of subdivisions (values above 1 will smooth curves that don't need it)"}; +cvar_t r_subdivisions_mintess = {0, "r_subdivisions_mintess", "0", "minimum number of subdivisions (values above 0 will smooth curves that don't need it)"}; cvar_t r_subdivisions_maxtess = {0, "r_subdivisions_maxtess", "1024", "maximum number of subdivisions (prevents curves beyond a certain detail level, limits smoothing)"}; cvar_t r_subdivisions_maxvertices = {0, "r_subdivisions_maxvertices", "65536", "maximum vertices allowed per subdivided curve"}; cvar_t r_subdivisions_collision_tolerance = {0, "r_subdivisions_collision_tolerance", "15", "maximum error tolerance on curve subdivision for collision purposes (usually a larger error tolerance than for rendering)"}; -cvar_t r_subdivisions_collision_mintess = {0, "r_subdivisions_collision_mintess", "1", "minimum number of subdivisions (values above 1 will smooth curves that don't need it)"}; +cvar_t r_subdivisions_collision_mintess = {0, "r_subdivisions_collision_mintess", "0", "minimum number of subdivisions (values above 0 will smooth curves that don't need it)"}; cvar_t r_subdivisions_collision_maxtess = {0, "r_subdivisions_collision_maxtess", "1024", "maximum number of subdivisions (prevents curves beyond a certain detail level, limits smoothing)"}; cvar_t r_subdivisions_collision_maxvertices = {0, "r_subdivisions_collision_maxvertices", "4225", "maximum vertices allowed per subdivided curve"}; cvar_t mod_q3bsp_curves_collisions = {0, "mod_q3bsp_curves_collisions", "1", "enables collisions with curves (SLOW)"}; +cvar_t mod_q3bsp_curves_collisions_stride = {0, "mod_q3bsp_curves_collisions_stride", "16", "collisions against curves: optimize performance by doing a combined collision check for this triangle amount first (-1 avoids any box tests)"}; +cvar_t mod_q3bsp_curves_stride = {0, "mod_q3bsp_curves_stride", "16", "particle effect collisions against curves: optimize performance by doing a combined collision check for this triangle amount first (-1 avoids any box tests)"}; cvar_t mod_q3bsp_optimizedtraceline = {0, "mod_q3bsp_optimizedtraceline", "1", "whether to use optimized traceline code for line traces (as opposed to tracebox code)"}; cvar_t mod_q3bsp_debugtracebrush = {0, "mod_q3bsp_debugtracebrush", "0", "selects different tracebrush bsp recursion algorithms (for debugging purposes only)"}; cvar_t mod_q3bsp_lightmapmergepower = {CVAR_SAVE, "mod_q3bsp_lightmapmergepower", "4", "merges the quake3 128x128 lightmap textures into larger lightmap group textures to speed up rendering, 1 = 256x256, 2 = 512x512, 3 = 1024x1024, 4 = 2048x2048, 5 = 4096x4096, ..."}; +cvar_t mod_q3bsp_nolightmaps = {CVAR_SAVE, "mod_q3bsp_nolightmaps", "0", "do not load lightmaps in Q3BSP maps (to save video RAM, but be warned: it looks ugly)"}; +cvar_t mod_q3bsp_tracelineofsight_brushes = {0, "mod_q3bsp_tracelineofsight_brushes", "0", "enables culling of entities behind detail brushes, curves, etc"}; static texture_t mod_q1bsp_texture_solid; static texture_t mod_q1bsp_texture_sky; @@ -55,10 +56,7 @@ static texture_t mod_q1bsp_texture_water; void Mod_BrushInit(void) { // Cvar_RegisterVariable(&r_subdivide_size); - Cvar_RegisterVariable(&halflifebsp); - Cvar_RegisterVariable(&mcbsp); Cvar_RegisterVariable(&r_novis); - Cvar_RegisterVariable(&r_lightmaprgba); Cvar_RegisterVariable(&r_picmipworld); Cvar_RegisterVariable(&r_nosurftextures); Cvar_RegisterVariable(&r_subdivisions_tolerance); @@ -70,9 +68,13 @@ void Mod_BrushInit(void) Cvar_RegisterVariable(&r_subdivisions_collision_maxtess); Cvar_RegisterVariable(&r_subdivisions_collision_maxvertices); Cvar_RegisterVariable(&mod_q3bsp_curves_collisions); + Cvar_RegisterVariable(&mod_q3bsp_curves_collisions_stride); + Cvar_RegisterVariable(&mod_q3bsp_curves_stride); Cvar_RegisterVariable(&mod_q3bsp_optimizedtraceline); Cvar_RegisterVariable(&mod_q3bsp_debugtracebrush); Cvar_RegisterVariable(&mod_q3bsp_lightmapmergepower); + Cvar_RegisterVariable(&mod_q3bsp_nolightmaps); + Cvar_RegisterVariable(&mod_q3bsp_tracelineofsight_brushes); memset(&mod_q1bsp_texture_solid, 0, sizeof(mod_q1bsp_texture_solid)); strlcpy(mod_q1bsp_texture_solid.name, "solid" , sizeof(mod_q1bsp_texture_solid.name)); @@ -100,7 +102,7 @@ void Mod_BrushInit(void) mod_q1bsp_texture_water.supercontents = SUPERCONTENTS_WATER; } -static mleaf_t *Mod_Q1BSP_PointInLeaf(model_t *model, const vec3_t p) +static mleaf_t *Mod_Q1BSP_PointInLeaf(dp_model_t *model, const vec3_t p) { mnode_t *node; @@ -116,7 +118,7 @@ static mleaf_t *Mod_Q1BSP_PointInLeaf(model_t *model, const vec3_t p) return (mleaf_t *)node; } -static void Mod_Q1BSP_AmbientSoundLevelsForPoint(model_t *model, const vec3_t p, unsigned char *out, int outsize) +static void Mod_Q1BSP_AmbientSoundLevelsForPoint(dp_model_t *model, const vec3_t p, unsigned char *out, int outsize) { int i; mleaf_t *leaf; @@ -135,14 +137,14 @@ static void Mod_Q1BSP_AmbientSoundLevelsForPoint(model_t *model, const vec3_t p, memset(out, 0, outsize); } -static int Mod_Q1BSP_FindBoxClusters(model_t *model, const vec3_t mins, const vec3_t maxs, int maxclusters, int *clusterlist) +static int Mod_Q1BSP_FindBoxClusters(dp_model_t *model, const vec3_t mins, const vec3_t maxs, int maxclusters, int *clusterlist) { int numclusters = 0; int nodestackindex = 0; mnode_t *node, *nodestack[1024]; if (!model->brush.num_pvsclusters) return -1; - node = model->brush.data_nodes; + node = model->brush.data_nodes + model->brushq1.hulls[0].firstclipnode; for (;;) { #if 1 @@ -201,13 +203,13 @@ static int Mod_Q1BSP_FindBoxClusters(model_t *model, const vec3_t mins, const ve return numclusters; } -static int Mod_Q1BSP_BoxTouchingPVS(model_t *model, const unsigned char *pvs, const vec3_t mins, const vec3_t maxs) +static int Mod_Q1BSP_BoxTouchingPVS(dp_model_t *model, const unsigned char *pvs, const vec3_t mins, const vec3_t maxs) { int nodestackindex = 0; mnode_t *node, *nodestack[1024]; if (!model->brush.num_pvsclusters) return true; - node = model->brush.data_nodes; + node = model->brush.data_nodes + model->brushq1.hulls[0].firstclipnode; for (;;) { #if 1 @@ -272,13 +274,13 @@ static int Mod_Q1BSP_BoxTouchingPVS(model_t *model, const unsigned char *pvs, co return false; } -static int Mod_Q1BSP_BoxTouchingLeafPVS(model_t *model, const unsigned char *pvs, const vec3_t mins, const vec3_t maxs) +static int Mod_Q1BSP_BoxTouchingLeafPVS(dp_model_t *model, const unsigned char *pvs, const vec3_t mins, const vec3_t maxs) { int nodestackindex = 0; mnode_t *node, *nodestack[1024]; if (!model->brush.num_leafs) return true; - node = model->brush.data_nodes; + node = model->brush.data_nodes + model->brushq1.hulls[0].firstclipnode; for (;;) { #if 1 @@ -343,13 +345,13 @@ static int Mod_Q1BSP_BoxTouchingLeafPVS(model_t *model, const unsigned char *pvs return false; } -static int Mod_Q1BSP_BoxTouchingVisibleLeafs(model_t *model, const unsigned char *visibleleafs, const vec3_t mins, const vec3_t maxs) +static int Mod_Q1BSP_BoxTouchingVisibleLeafs(dp_model_t *model, const unsigned char *visibleleafs, const vec3_t mins, const vec3_t maxs) { int nodestackindex = 0; mnode_t *node, *nodestack[1024]; if (!model->brush.num_leafs) return true; - node = model->brush.data_nodes; + node = model->brush.data_nodes + model->brushq1.hulls[0].firstclipnode; for (;;) { #if 1 @@ -415,107 +417,136 @@ static int Mod_Q1BSP_BoxTouchingVisibleLeafs(model_t *model, const unsigned char typedef struct findnonsolidlocationinfo_s { vec3_t center; + vec3_t absmin, absmax; vec_t radius; vec3_t nudge; vec_t bestdist; - model_t *model; + dp_model_t *model; } findnonsolidlocationinfo_t; -static void Mod_Q1BSP_FindNonSolidLocation_r_Leaf(findnonsolidlocationinfo_t *info, mleaf_t *leaf) +static void Mod_Q1BSP_FindNonSolidLocation_r_Triangle(findnonsolidlocationinfo_t *info, msurface_t *surface, int k) { - int i, surfacenum, k, *tri, *mark; + int i, *tri; float dist, f, vert[3][3], edge[3][3], facenormal[3], edgenormal[3][3], point[3]; + + tri = (info->model->surfmesh.data_element3i + 3 * surface->num_firsttriangle) + k * 3; + VectorCopy((info->model->surfmesh.data_vertex3f + tri[0] * 3), vert[0]); + VectorCopy((info->model->surfmesh.data_vertex3f + tri[1] * 3), vert[1]); + VectorCopy((info->model->surfmesh.data_vertex3f + tri[2] * 3), vert[2]); + VectorSubtract(vert[1], vert[0], edge[0]); + VectorSubtract(vert[2], vert[1], edge[1]); + CrossProduct(edge[1], edge[0], facenormal); + if (facenormal[0] || facenormal[1] || facenormal[2]) + { + VectorNormalize(facenormal); + f = DotProduct(info->center, facenormal) - DotProduct(vert[0], facenormal); + if (f <= info->bestdist && f >= -info->bestdist) + { + VectorSubtract(vert[0], vert[2], edge[2]); + VectorNormalize(edge[0]); + VectorNormalize(edge[1]); + VectorNormalize(edge[2]); + CrossProduct(facenormal, edge[0], edgenormal[0]); + CrossProduct(facenormal, edge[1], edgenormal[1]); + CrossProduct(facenormal, edge[2], edgenormal[2]); + // face distance + if (DotProduct(info->center, edgenormal[0]) < DotProduct(vert[0], edgenormal[0]) + && DotProduct(info->center, edgenormal[1]) < DotProduct(vert[1], edgenormal[1]) + && DotProduct(info->center, edgenormal[2]) < DotProduct(vert[2], edgenormal[2])) + { + // we got lucky, the center is within the face + dist = DotProduct(info->center, facenormal) - DotProduct(vert[0], facenormal); + if (dist < 0) + { + dist = -dist; + if (info->bestdist > dist) + { + info->bestdist = dist; + VectorScale(facenormal, (info->radius - -dist), info->nudge); + } + } + else + { + if (info->bestdist > dist) + { + info->bestdist = dist; + VectorScale(facenormal, (info->radius - dist), info->nudge); + } + } + } + else + { + // check which edge or vertex the center is nearest + for (i = 0;i < 3;i++) + { + f = DotProduct(info->center, edge[i]); + if (f >= DotProduct(vert[0], edge[i]) + && f <= DotProduct(vert[1], edge[i])) + { + // on edge + VectorMA(info->center, -f, edge[i], point); + dist = sqrt(DotProduct(point, point)); + if (info->bestdist > dist) + { + info->bestdist = dist; + VectorScale(point, (info->radius / dist), info->nudge); + } + // skip both vertex checks + // (both are further away than this edge) + i++; + } + else + { + // not on edge, check first vertex of edge + VectorSubtract(info->center, vert[i], point); + dist = sqrt(DotProduct(point, point)); + if (info->bestdist > dist) + { + info->bestdist = dist; + VectorScale(point, (info->radius / dist), info->nudge); + } + } + } + } + } + } +} + +static void Mod_Q1BSP_FindNonSolidLocation_r_Leaf(findnonsolidlocationinfo_t *info, mleaf_t *leaf) +{ + int surfacenum, k, *mark; msurface_t *surface; for (surfacenum = 0, mark = leaf->firstleafsurface;surfacenum < leaf->numleafsurfaces;surfacenum++, mark++) { surface = info->model->data_surfaces + *mark; if (surface->texture->supercontents & SUPERCONTENTS_SOLID) { - for (k = 0;k < surface->num_triangles;k++) + if(surface->num_bboxstride > 0) { - tri = (info->model->surfmesh.data_element3i + 3 * surface->num_firsttriangle) + k * 3; - VectorCopy((info->model->surfmesh.data_vertex3f + tri[0] * 3), vert[0]); - VectorCopy((info->model->surfmesh.data_vertex3f + tri[1] * 3), vert[1]); - VectorCopy((info->model->surfmesh.data_vertex3f + tri[2] * 3), vert[2]); - VectorSubtract(vert[1], vert[0], edge[0]); - VectorSubtract(vert[2], vert[1], edge[1]); - CrossProduct(edge[1], edge[0], facenormal); - if (facenormal[0] || facenormal[1] || facenormal[2]) + int i, cnt, tri; + cnt = (surface->num_triangles + surface->num_bboxstride - 1) / surface->num_bboxstride; + for(i = 0; i < cnt; ++i) { - VectorNormalize(facenormal); - f = DotProduct(info->center, facenormal) - DotProduct(vert[0], facenormal); - if (f <= info->bestdist && f >= -info->bestdist) + if(BoxesOverlap(surface->data_bbox6f + i * 6, surface->data_bbox6f + i * 6 + 3, info->absmin, info->absmax)) { - VectorSubtract(vert[0], vert[2], edge[2]); - VectorNormalize(edge[0]); - VectorNormalize(edge[1]); - VectorNormalize(edge[2]); - CrossProduct(facenormal, edge[0], edgenormal[0]); - CrossProduct(facenormal, edge[1], edgenormal[1]); - CrossProduct(facenormal, edge[2], edgenormal[2]); - // face distance - if (DotProduct(info->center, edgenormal[0]) < DotProduct(vert[0], edgenormal[0]) - && DotProduct(info->center, edgenormal[1]) < DotProduct(vert[1], edgenormal[1]) - && DotProduct(info->center, edgenormal[2]) < DotProduct(vert[2], edgenormal[2])) - { - // we got lucky, the center is within the face - dist = DotProduct(info->center, facenormal) - DotProduct(vert[0], facenormal); - if (dist < 0) - { - dist = -dist; - if (info->bestdist > dist) - { - info->bestdist = dist; - VectorScale(facenormal, (info->radius - -dist), info->nudge); - } - } - else - { - if (info->bestdist > dist) - { - info->bestdist = dist; - VectorScale(facenormal, (info->radius - dist), info->nudge); - } - } - } - else + for(k = 0; k < surface->num_bboxstride; ++k) { - // check which edge or vertex the center is nearest - for (i = 0;i < 3;i++) - { - f = DotProduct(info->center, edge[i]); - if (f >= DotProduct(vert[0], edge[i]) - && f <= DotProduct(vert[1], edge[i])) - { - // on edge - VectorMA(info->center, -f, edge[i], point); - dist = sqrt(DotProduct(point, point)); - if (info->bestdist > dist) - { - info->bestdist = dist; - VectorScale(point, (info->radius / dist), info->nudge); - } - // skip both vertex checks - // (both are further away than this edge) - i++; - } - else - { - // not on edge, check first vertex of edge - VectorSubtract(info->center, vert[i], point); - dist = sqrt(DotProduct(point, point)); - if (info->bestdist > dist) - { - info->bestdist = dist; - VectorScale(point, (info->radius / dist), info->nudge); - } - } - } + tri = i * surface->num_bboxstride + k; + if(tri >= surface->num_triangles) + break; + Mod_Q1BSP_FindNonSolidLocation_r_Triangle(info, surface, tri); } } } } + else + { + for (k = 0;k < surface->num_triangles;k++) + { + Mod_Q1BSP_FindNonSolidLocation_r_Triangle(info, surface, k); + } + } } } } @@ -537,7 +568,7 @@ static void Mod_Q1BSP_FindNonSolidLocation_r(findnonsolidlocationinfo_t *info, m } } -static void Mod_Q1BSP_FindNonSolidLocation(model_t *model, const vec3_t in, vec3_t out, float radius) +static void Mod_Q1BSP_FindNonSolidLocation(dp_model_t *model, const vec3_t in, vec3_t out, float radius) { int i; findnonsolidlocationinfo_t info; @@ -554,6 +585,14 @@ static void Mod_Q1BSP_FindNonSolidLocation(model_t *model, const vec3_t in, vec3 { VectorClear(info.nudge); info.bestdist = radius; + VectorCopy(info.center, info.absmin); + VectorCopy(info.center, info.absmax); + info.absmin[0] -= info.radius + 1; + info.absmin[1] -= info.radius + 1; + info.absmin[2] -= info.radius + 1; + info.absmax[0] += info.radius + 1; + info.absmax[1] += info.radius + 1; + info.absmax[2] += info.radius + 1; Mod_Q1BSP_FindNonSolidLocation_r(&info, model->brush.data_nodes + model->brushq1.hulls[0].firstclipnode); VectorAdd(info.center, info.nudge, info.center); } @@ -561,14 +600,14 @@ static void Mod_Q1BSP_FindNonSolidLocation(model_t *model, const vec3_t in, vec3 VectorCopy(info.center, out); } -int Mod_Q1BSP_SuperContentsFromNativeContents(model_t *model, int nativecontents) +int Mod_Q1BSP_SuperContentsFromNativeContents(dp_model_t *model, int nativecontents) { switch(nativecontents) { case CONTENTS_EMPTY: return 0; case CONTENTS_SOLID: - return SUPERCONTENTS_SOLID; + return SUPERCONTENTS_SOLID | SUPERCONTENTS_OPAQUE; case CONTENTS_WATER: return SUPERCONTENTS_WATER; case CONTENTS_SLIME: @@ -576,12 +615,12 @@ int Mod_Q1BSP_SuperContentsFromNativeContents(model_t *model, int nativecontents case CONTENTS_LAVA: return SUPERCONTENTS_LAVA | SUPERCONTENTS_NODROP; case CONTENTS_SKY: - return SUPERCONTENTS_SKY | SUPERCONTENTS_NODROP; + return SUPERCONTENTS_SKY | SUPERCONTENTS_NODROP | SUPERCONTENTS_OPAQUE; // to match behaviour of Q3 maps, let sky count as opaque } 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; @@ -785,8 +824,16 @@ loc0: //#if COLLISIONPARANOID < 2 static int Mod_Q1BSP_RecursiveHullCheckPoint(RecursiveHullCheckTraceInfo_t *t, int num) { + mplane_t *plane; + mclipnode_t *nodes = t->hull->clipnodes; + mplane_t *planes = t->hull->planes; + vec3_t point; + VectorCopy(t->start, point); while (num >= 0) - num = t->hull->clipnodes[num].children[(t->hull->planes[t->hull->clipnodes[num].planenum].type < 3 ? t->start[t->hull->planes[t->hull->clipnodes[num].planenum].type] : DotProduct(t->hull->planes[t->hull->clipnodes[num].planenum].normal, t->start)) < t->hull->planes[t->hull->clipnodes[num].planenum].dist]; + { + plane = planes + nodes[num].planenum; + num = nodes[num].children[(plane->type < 3 ? point[plane->type] : DotProduct(plane->normal, point)) < plane->dist]; + } num = Mod_Q1BSP_SuperContentsFromNativeContents(NULL, num); t->trace->startsupercontents |= num; if (num & SUPERCONTENTS_LIQUIDSMASK) @@ -806,12 +853,32 @@ static int Mod_Q1BSP_RecursiveHullCheckPoint(RecursiveHullCheckTraceInfo_t *t, i } //#endif -static void Mod_Q1BSP_TraceBox(struct model_s *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_Q1BSP_TracePoint(struct model_s *model, const frameblend_t *frameblend, const skeleton_t *skeleton, trace_t *trace, const vec3_t start, int hitsupercontentsmask) +{ + RecursiveHullCheckTraceInfo_t rhc; + + memset(&rhc, 0, sizeof(rhc)); + memset(trace, 0, sizeof(trace_t)); + rhc.trace = trace; + rhc.trace->fraction = 1; + rhc.trace->realfraction = 1; + rhc.trace->allsolid = true; + rhc.hull = &model->brushq1.hulls[0]; // 0x0x0 + VectorCopy(start, rhc.start); + VectorCopy(start, rhc.end); + Mod_Q1BSP_RecursiveHullCheckPoint(&rhc, rhc.hull->firstclipnode); +} + +static void Mod_Q1BSP_TraceLine(struct model_s *model, const frameblend_t *frameblend, const skeleton_t *skeleton, trace_t *trace, const vec3_t start, const vec3_t end, int hitsupercontentsmask) { - // this function currently only supports same size start and end - double boxsize[3]; RecursiveHullCheckTraceInfo_t rhc; + if (VectorCompare(start, end)) + { + Mod_Q1BSP_TracePoint(model, frameblend, skeleton, trace, start, hitsupercontentsmask); + return; + } + memset(&rhc, 0, sizeof(rhc)); memset(trace, 0, sizeof(trace_t)); rhc.trace = trace; @@ -819,32 +886,66 @@ static void Mod_Q1BSP_TraceBox(struct model_s *model, int frame, trace_t *trace, rhc.trace->fraction = 1; rhc.trace->realfraction = 1; rhc.trace->allsolid = true; - VectorSubtract(boxmaxs, boxmins, boxsize); - if (boxsize[0] < 3) - rhc.hull = &model->brushq1.hulls[0]; // 0x0x0 - else if (model->brush.ismcbsp) + rhc.hull = &model->brushq1.hulls[0]; // 0x0x0 + VectorCopy(start, rhc.start); + VectorCopy(end, rhc.end); + VectorSubtract(rhc.end, rhc.start, rhc.dist); +#if COLLISIONPARANOID >= 2 + Con_Printf("t(%f %f %f,%f %f %f)", rhc.start[0], rhc.start[1], rhc.start[2], rhc.end[0], rhc.end[1], rhc.end[2]); + Mod_Q1BSP_RecursiveHullCheck(&rhc, rhc.hull->firstclipnode, 0, 1, rhc.start, rhc.end); { - int i; - float vdist, dist; - int vdisti = 0; - vdist = 0; // shut up compiler warning + double test[3]; + trace_t testtrace; + VectorLerp(rhc.start, rhc.trace->fraction, rhc.end, test); + memset(&testtrace, 0, sizeof(trace_t)); + rhc.trace = &testtrace; + rhc.trace->hitsupercontentsmask = hitsupercontentsmask; + rhc.trace->fraction = 1; + rhc.trace->realfraction = 1; + rhc.trace->allsolid = true; + VectorCopy(test, rhc.start); + VectorCopy(test, rhc.end); + VectorClear(rhc.dist); + Mod_Q1BSP_RecursiveHullCheckPoint(&rhc, rhc.hull->firstclipnode); + //Mod_Q1BSP_RecursiveHullCheck(&rhc, rhc.hull->firstclipnode, 0, 1, test, test); + if (!trace->startsolid && testtrace.startsolid) + Con_Printf(" - ended in solid!\n"); + } + Con_Print("\n"); +#else + if (VectorLength2(rhc.dist)) + Mod_Q1BSP_RecursiveHullCheck(&rhc, rhc.hull->firstclipnode, 0, 1, rhc.start, rhc.end); + else + Mod_Q1BSP_RecursiveHullCheckPoint(&rhc, rhc.hull->firstclipnode); +#endif +} - // find the closest hull size (this algorithm probably sucks, a qc field to override it might be in order...) - for (i = 1; i < model->brushq1.numhulls; i++) - { - dist = fabs(model->brushq1.hulls[i].clip_size[0] - boxsize[0]) + - fabs(model->brushq1.hulls[i].clip_size[1] - boxsize[1]) + - fabs(model->brushq1.hulls[i].clip_size[2] - boxsize[2]) * 0.25; +static void Mod_Q1BSP_TraceBox(struct model_s *model, const frameblend_t *frameblend, const skeleton_t *skeleton, trace_t *trace, const vec3_t start, const vec3_t boxmins, const vec3_t boxmaxs, const vec3_t end, int hitsupercontentsmask) +{ + // this function currently only supports same size start and end + double boxsize[3]; + RecursiveHullCheckTraceInfo_t rhc; - if (!vdisti || dist < vdist) - { - vdisti = i; - vdist = dist; - } - } - rhc.hull = &model->brushq1.hulls[vdisti]; + if (VectorCompare(boxmins, boxmaxs)) + { + if (VectorCompare(start, end)) + Mod_Q1BSP_TracePoint(model, frameblend, skeleton, trace, start, hitsupercontentsmask); + else + Mod_Q1BSP_TraceLine(model, frameblend, skeleton, trace, start, end, hitsupercontentsmask); + return; } + + memset(&rhc, 0, sizeof(rhc)); + memset(trace, 0, sizeof(trace_t)); + rhc.trace = trace; + rhc.trace->hitsupercontentsmask = hitsupercontentsmask; + rhc.trace->fraction = 1; + rhc.trace->realfraction = 1; + rhc.trace->allsolid = true; + VectorSubtract(boxmaxs, boxmins, boxsize); + if (boxsize[0] < 3) + rhc.hull = &model->brushq1.hulls[0]; // 0x0x0 else if (model->brush.ishlbsp) { // LordHavoc: this has to have a minor tolerance (the .1) because of @@ -902,11 +1003,27 @@ static void Mod_Q1BSP_TraceBox(struct model_s *model, int frame, trace_t *trace, #endif } +static int Mod_Q1BSP_PointSuperContents(struct model_s *model, int frame, const vec3_t point) +{ + int num = model->brushq1.hulls[0].firstclipnode; + mplane_t *plane; + mclipnode_t *nodes = model->brushq1.hulls[0].clipnodes; + mplane_t *planes = model->brushq1.hulls[0].planes; + while (num >= 0) + { + plane = planes + nodes[num].planenum; + num = nodes[num].children[(plane->type < 3 ? point[plane->type] : DotProduct(plane->normal, point)) < plane->dist]; + } + return Mod_Q1BSP_SuperContentsFromNativeContents(NULL, num); +} + void Collision_ClipTrace_Box(trace_t *trace, const vec3_t cmins, const vec3_t cmaxs, const vec3_t start, const vec3_t mins, const vec3_t maxs, const vec3_t end, int hitsupercontentsmask, int boxsupercontents, int boxq3surfaceflags, texture_t *boxtexture) { #if 1 colbrushf_t cbox; colplanef_t cbox_planes[6]; + cbox.isaabb = true; + cbox.hasaabbplanes = true; cbox.supercontents = boxsupercontents; cbox.numplanes = 6; cbox.numpoints = 0; @@ -1006,77 +1123,30 @@ void Collision_ClipTrace_Box(trace_t *trace, const vec3_t cmins, const vec3_t cm #endif } -static int Mod_Q1BSP_TraceLineOfSight_RecursiveNodeCheck(mnode_t *node, double p1[3], double p2[3]) +void Collision_ClipTrace_Point(trace_t *trace, const vec3_t cmins, const vec3_t cmaxs, const vec3_t start, int hitsupercontentsmask, int boxsupercontents, int boxq3surfaceflags, texture_t *boxtexture) { - double t1, t2; - double midf, mid[3]; - int ret, side; - - // check for empty - while (node->plane) + memset(trace, 0, sizeof(trace_t)); + trace->fraction = 1; + trace->realfraction = 1; + if (BoxesOverlap(start, start, cmins, cmaxs)) { - // find the point distances - mplane_t *plane = node->plane; - if (plane->type < 3) - { - t1 = p1[plane->type] - plane->dist; - t2 = p2[plane->type] - plane->dist; - } - else - { - t1 = DotProduct (plane->normal, p1) - plane->dist; - t2 = DotProduct (plane->normal, p2) - plane->dist; - } - - if (t1 < 0) + trace->startsupercontents |= boxsupercontents; + if (hitsupercontentsmask & boxsupercontents) { - if (t2 < 0) - { - node = node->children[1]; - continue; - } - side = 1; - } - else - { - if (t2 >= 0) - { - node = node->children[0]; - continue; - } - side = 0; + trace->startsolid = true; + trace->allsolid = true; } - - midf = t1 / (t1 - t2); - VectorLerp(p1, midf, p2, mid); - - // recurse both sides, front side first - // return 2 if empty is followed by solid (hit something) - // do not return 2 if both are solid or both empty, - // or if start is solid and end is empty - // as these degenerate cases usually indicate the eye is in solid and - // should see the target point anyway - ret = Mod_Q1BSP_TraceLineOfSight_RecursiveNodeCheck(node->children[side ], p1, mid); - if (ret != 0) - return ret; - ret = Mod_Q1BSP_TraceLineOfSight_RecursiveNodeCheck(node->children[side ^ 1], mid, p2); - if (ret != 1) - return ret; - return 2; } - return ((mleaf_t *)node)->clusterindex < 0; } static qboolean Mod_Q1BSP_TraceLineOfSight(struct model_s *model, const vec3_t start, const vec3_t end) { - // this function currently only supports same size start and end - double tracestart[3], traceend[3]; - VectorCopy(start, tracestart); - VectorCopy(end, traceend); - return Mod_Q1BSP_TraceLineOfSight_RecursiveNodeCheck(model->brush.data_nodes, tracestart, traceend) != 2; + trace_t trace; + model->TraceLine(model, NULL, NULL, &trace, start, end, SUPERCONTENTS_VISBLOCKERMASK); + return trace.fraction == 1; } -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; @@ -1127,8 +1197,14 @@ loc0: // check for impact on this node if (node->numsurfaces) { - int i, ds, dt; + int i, dsi, dti, lmwidth, lmheight; + float ds, dt; msurface_t *surface; + unsigned char *lightmap; + int maps, line3, size3; + float dsfrac; + float dtfrac; + float scale, w, w00, w01, w10, w11; surface = model->data_surfaces + node->firstsurface; for (i = 0;i < node->numsurfaces;i++, surface++) @@ -1136,66 +1212,46 @@ loc0: if (!(surface->texture->basematerialflags & MATERIALFLAG_WALL) || !surface->lightmapinfo->samples) continue; // no lightmaps - ds = (int) (x * surface->lightmapinfo->texinfo->vecs[0][0] + y * surface->lightmapinfo->texinfo->vecs[0][1] + mid * surface->lightmapinfo->texinfo->vecs[0][2] + surface->lightmapinfo->texinfo->vecs[0][3]) - surface->lightmapinfo->texturemins[0]; - dt = (int) (x * surface->lightmapinfo->texinfo->vecs[1][0] + y * surface->lightmapinfo->texinfo->vecs[1][1] + mid * surface->lightmapinfo->texinfo->vecs[1][2] + surface->lightmapinfo->texinfo->vecs[1][3]) - surface->lightmapinfo->texturemins[1]; + // location we want to sample in the lightmap + ds = ((x * surface->lightmapinfo->texinfo->vecs[0][0] + y * surface->lightmapinfo->texinfo->vecs[0][1] + mid * surface->lightmapinfo->texinfo->vecs[0][2] + surface->lightmapinfo->texinfo->vecs[0][3]) - surface->lightmapinfo->texturemins[0]) * 0.0625f; + dt = ((x * surface->lightmapinfo->texinfo->vecs[1][0] + y * surface->lightmapinfo->texinfo->vecs[1][1] + mid * surface->lightmapinfo->texinfo->vecs[1][2] + surface->lightmapinfo->texinfo->vecs[1][3]) - surface->lightmapinfo->texturemins[1]) * 0.0625f; - if (ds >= 0 && ds < surface->lightmapinfo->extents[0] && dt >= 0 && dt < surface->lightmapinfo->extents[1]) + // check the bounds + dsi = (int)ds; + dti = (int)dt; + lmwidth = ((surface->lightmapinfo->extents[0]>>4)+1); + lmheight = ((surface->lightmapinfo->extents[1]>>4)+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 } } @@ -1209,7 +1265,7 @@ middle sample (the one which was requested) } } -void Mod_Q1BSP_LightPoint(model_t *model, const vec3_t p, vec3_t ambientcolor, vec3_t diffusecolor, vec3_t diffusenormal) +void Mod_Q1BSP_LightPoint(dp_model_t *model, const vec3_t p, vec3_t ambientcolor, vec3_t diffusecolor, vec3_t diffusenormal) { // pretend lighting is coming down from above (due to lack of a lightgrid to know primary lighting direction) VectorSet(diffusenormal, 0, 0, 1); @@ -1267,29 +1323,24 @@ A sky texture is 256*128, with the right side being a masked overlay */ void R_Q1BSP_LoadSplitSky (unsigned char *src, int width, int height, int bytesperpixel) { - int i, j; - unsigned solidpixels[128*128], alphapixels[128*128]; + int x, y; + int w = width/2; + int h = height; + unsigned *solidpixels = Mem_Alloc(tempmempool, w*h*sizeof(unsigned char[4])); + unsigned *alphapixels = Mem_Alloc(tempmempool, w*h*sizeof(unsigned char[4])); // allocate a texture pool if we need it 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++) + for (y = 0;y < h;y++) { - for (j = 0;j < 128;j++) + for (x = 0;x < w;x++) { - solidpixels[(i*128) + j] = ((unsigned *)src)[i*256+j+128]; - alphapixels[(i*128) + j] = ((unsigned *)src)[i*256+j]; + solidpixels[y*w+x] = ((unsigned *)src)[y*width+x+w]; + alphapixels[y*w+x] = ((unsigned *)src)[y*width+x]; } } } @@ -1303,34 +1354,37 @@ void R_Q1BSP_LoadSplitSky (unsigned char *src, int width, int height, int bytesp unsigned int i; unsigned char b[4]; } - rgba; + bgra; r = g = b = 0; - for (i = 0;i < 128;i++) + for (y = 0;y < h;y++) { - for (j = 0;j < 128;j++) + for (x = 0;x < w;x++) { - rgba.i = palette_complete[src[i*256 + j + 128]]; - r += rgba.b[0]; - g += rgba.b[1]; - b += rgba.b[2]; + p = src[x*width+y+w]; + 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; - for (i = 0;i < 128;i++) + bgra.b[2] = r/(w*h); + bgra.b[1] = g/(w*h); + bgra.b[0] = b/(w*h); + bgra.b[3] = 0; + for (y = 0;y < h;y++) { - for (j = 0;j < 128;j++) + for (x = 0;x < w;x++) { - 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[y*w+x] = palette_bgra_complete[src[y*width+x+w]]; + p = src[y*width+x]; + alphapixels[y*w+x] = 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.solidskyskinframe = R_SkinFrame_LoadInternalBGRA("sky_solidtexture", TEXF_PRECACHE, (unsigned char *) solidpixels, w, h); + loadmodel->brush.alphaskyskinframe = R_SkinFrame_LoadInternalBGRA("sky_alphatexture", TEXF_ALPHA | TEXF_PRECACHE, (unsigned char *) alphapixels, w, h); + Mem_Free(solidpixels); + Mem_Free(alphapixels); } static void Mod_Q1BSP_LoadTextures(lump_t *l) @@ -1343,6 +1397,9 @@ 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; @@ -1379,17 +1436,16 @@ static void Mod_Q1BSP_LoadTextures(lump_t *l) 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; } @@ -1402,6 +1458,9 @@ static void Mod_Q1BSP_LoadTextures(lump_t *l) Vector4Set(tx->refractcolor4f, 1, 1, 1, 1); tx->reflectfactor = 1; Vector4Set(tx->reflectcolor4f, 1, 1, 1, 1); + tx->r_water_wateralpha = 1; + tx->specularscalemod = 1; + tx->specularpowermod = 1; } if (!m) @@ -1433,13 +1492,13 @@ static void Mod_Q1BSP_LoadTextures(lump_t *l) // 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;dmiptex->name[j] && j < 16;j++) + for (j = 0;j < 16 && dmiptex->name[j];j++) name[j] = dmiptex->name[j]; name[j] = 0; if (!name[0]) { - sprintf(name, "unnamed%i", i); + dpsnprintf(name, sizeof(name), "unnamed%i", i); Con_DPrintf("%s: warning: renaming unnamed texture to %s\n", loadmodel->name, name); } @@ -1466,7 +1525,7 @@ static void Mod_Q1BSP_LoadTextures(lump_t *l) if (name[j] >= 'A' && name[j] <= 'Z') name[j] += 'a' - 'A'; - if (dmiptex->name[0] && Mod_LoadTextureFromQ3Shader(loadmodel->data_textures + i, name, true, false, false)) + if (dmiptex->name[0] && Mod_LoadTextureFromQ3Shader(loadmodel->data_textures + i, name, false, false, 0)) continue; tx = loadmodel->data_textures + i; @@ -1506,25 +1565,22 @@ static void Mod_Q1BSP_LoadTextures(lump_t *l) if (cls.state != ca_dedicated) { // LordHavoc: HL sky textures are entirely different than quake - if (!loadmodel->brush.ishlbsp && !strncmp(tx->name, "sky", 3) && mtwidth == 256 && mtheight == 128) + if (!loadmodel->brush.ishlbsp && !strncmp(tx->name, "sky", 3) && mtwidth == mtheight * 2) { - if (loadmodel->isworldmodel) + data = loadimagepixelsbgra(tx->name, false, false); + if (data && image_width == image_height * 2) { - data = loadimagepixels(tx->name, false, 0, 0, false); - if (data) - { - R_Q1BSP_LoadSplitSky(data, image_width, image_height, 4); - Mem_Free(data); - } - else if (mtdata != NULL) - R_Q1BSP_LoadSplitSky(mtdata, mtwidth, mtheight, 1); + R_Q1BSP_LoadSplitSky(data, image_width, image_height, 4); + Mem_Free(data); } + else if (mtdata != NULL) + R_Q1BSP_LoadSplitSky(mtdata, mtwidth, mtheight, 1); } else { - skinframe = R_SkinFrame_LoadExternal(gamemode == GAME_TENEBRAE ? tx->name : va("textures/%s/%s", mapname, tx->name), TEXF_MIPMAP | TEXF_ALPHA | TEXF_PRECACHE | (r_picmipworld.integer ? TEXF_PICMIP : 0) | TEXF_COMPRESS, false); + skinframe = R_SkinFrame_LoadExternal(gamemode == GAME_TENEBRAE ? tx->name : va("textures/%s/%s", mapname, tx->name), TEXF_ALPHA | 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 | (r_picmipworld.integer ? TEXF_PICMIP : 0) | TEXF_COMPRESS, false); + skinframe = R_SkinFrame_LoadExternal(gamemode == GAME_TENEBRAE ? tx->name : va("textures/%s", tx->name), TEXF_ALPHA | 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 @@ -1534,46 +1590,64 @@ static void Mod_Q1BSP_LoadTextures(lump_t *l) unsigned char *pixels, *freepixels; pixels = freepixels = NULL; if (mtdata) - pixels = W_ConvertWAD3Texture(dmiptex); + pixels = W_ConvertWAD3TextureBGRA(dmiptex); if (pixels == NULL) - pixels = freepixels = W_GetTexture(tx->name); + pixels = freepixels = W_GetTextureBGRA(tx->name); if (pixels != NULL) { tx->width = image_width; tx->height = image_height; - skinframe = R_SkinFrame_LoadInternal(tx->name, TEXF_MIPMAP | TEXF_ALPHA | TEXF_PRECACHE | (r_picmipworld.integer ? TEXF_PICMIP : 0), false, false, pixels, image_width, image_height, 32, NULL, NULL); + skinframe = R_SkinFrame_LoadInternalBGRA(tx->name, TEXF_ALPHA | 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 | (r_picmipworld.integer ? TEXF_PICMIP : 0), false, r_fullbrights.integer, mtdata, tx->width, tx->height, 8, NULL, NULL); + skinframe = R_SkinFrame_LoadInternalQuake(tx->name, TEXF_PRECACHE | TEXF_MIPMAP | (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; + tx->basematerialflags = MATERIALFLAG_WALL; 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 | MATERIALFLAG_WATERSHADER; - tx->basematerialflags |= MATERIALFLAG_WATER | MATERIALFLAG_LIGHTBOTHSIDES | MATERIALFLAG_NOSHADOW; + 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]->hasalpha) + tx->basematerialflags |= MATERIALFLAG_ALPHA | MATERIALFLAG_BLENDED | MATERIALFLAG_NOSHADOW; + } + else if (!strncmp(tx->name, "mirror", 6)) // Tenebrae + { + // replace the texture with black + tx->skinframes[0] = R_SkinFrame_LoadInternalBGRA(tx->name, TEXF_PRECACHE, zero, 1, 1); + tx->basematerialflags |= MATERIALFLAG_REFLECTION; } else if (!strncmp(tx->name, "sky", 3)) - tx->basematerialflags |= MATERIALFLAG_SKY | MATERIALFLAG_NOSHADOW; - else - tx->basematerialflags |= MATERIALFLAG_WALL; - if (tx->skinframes[0] && tx->skinframes[0]->fog) + tx->basematerialflags = MATERIALFLAG_SKY | MATERIALFLAG_NOSHADOW; + else if (!strcmp(tx->name, "caulk")) + tx->basematerialflags = MATERIALFLAG_NODRAW | MATERIALFLAG_NOSHADOW; + else if (tx->skinframes[0] && tx->skinframes[0]->hasalpha) tx->basematerialflags |= MATERIALFLAG_ALPHA | MATERIALFLAG_BLENDED | MATERIALFLAG_NOSHADOW; // start out with no animation tx->currentframe = tx; tx->currentskinframe = tx->skinframes[0]; + tx->specularscalemod = 1; // not supported here + tx->specularpowermod = 1; // not supported here } } @@ -1692,11 +1766,6 @@ static void Mod_Q1BSP_LoadLighting(lump_t *l) for (i=0; ifilelen; i++) loadmodel->brushq1.lightdata[i] = mod_base[l->fileofs+i] >>= 1; } - else if (loadmodel->brush.ismcbsp) - { - loadmodel->brushq1.lightdata = (unsigned char *)Mem_Alloc(loadmodel->mempool, l->filelen); - memcpy(loadmodel->brushq1.lightdata, mod_base + l->fileofs, l->filelen); - } else // LordHavoc: bsp version 29 (normal white lighting) { // LordHavoc: hope is not lost yet, check for a .lit file to load @@ -1713,7 +1782,8 @@ static void Mod_Q1BSP_LoadLighting(lump_t *l) i = LittleLong(((int *)data)[1]); if (i == 1) { - Con_DPrintf("loaded %s\n", litfilename); + if (developer_loading.integer) + Con_Printf("loaded %s\n", litfilename); loadmodel->brushq1.lightdata = (unsigned char *)Mem_Alloc(loadmodel->mempool, filesize - 8); memcpy(loadmodel->brushq1.lightdata, data + 8, filesize - 8); Mem_Free(data); @@ -1725,7 +1795,8 @@ static void Mod_Q1BSP_LoadLighting(lump_t *l) i = LittleLong(((int *)data)[1]); if (i == 1) { - Con_DPrintf("loaded %s\n", dlitfilename); + if (developer_loading.integer) + Con_Printf("loaded %s\n", dlitfilename); loadmodel->brushq1.nmaplightdata = (unsigned char *)Mem_Alloc(loadmodel->mempool, filesize - 8); memcpy(loadmodel->brushq1.nmaplightdata, data + 8, filesize - 8); loadmodel->brushq3.deluxemapping_modelspace = false; @@ -1781,7 +1852,6 @@ static void Mod_Q1BSP_LoadVisibility(lump_t *l) static void Mod_Q1BSP_ParseWadsFromEntityLump(const char *data) { char key[128], value[4096]; - char wadname[128]; int i, j, k; if (!data) return; @@ -1823,9 +1893,7 @@ static void Mod_Q1BSP_ParseWadsFromEntityLump(const char *data) { k = value[i]; value[i] = 0; - strlcpy(wadname, "textures/", sizeof(wadname)); - strlcat(wadname, &value[j], sizeof(wadname)); - W_LoadTextureWadFile(wadname, false); + W_LoadTextureWadFile(&value[j], false); j = i+1; if (!k) break; @@ -1842,8 +1910,9 @@ static void Mod_Q1BSP_LoadEntities(lump_t *l) loadmodel->brush.entities = NULL; if (!l->filelen) return; - loadmodel->brush.entities = (char *)Mem_Alloc(loadmodel->mempool, l->filelen); + loadmodel->brush.entities = (char *)Mem_Alloc(loadmodel->mempool, l->filelen + 1); memcpy(loadmodel->brush.entities, mod_base + l->fileofs, l->filelen); + loadmodel->brush.entities[l->filelen] = 0; if (loadmodel->brush.ishlbsp) Mod_Q1BSP_ParseWadsFromEntityLump(loadmodel->brush.entities); } @@ -1954,6 +2023,9 @@ static void Mod_Q1BSP_LoadEdges(lump_t *l) if (out->v[0] >= loadmodel->brushq1.numvertexes || out->v[1] >= loadmodel->brushq1.numvertexes) { Con_Printf("Mod_Q1BSP_LoadEdges: %s has invalid vertex indices in edge %i (vertices %i %i >= numvertices %i)\n", loadmodel->name, i, out->v[0], out->v[1], loadmodel->brushq1.numvertexes); + if(!loadmodel->brushq1.numvertexes) + Host_Error("Mod_Q1BSP_LoadEdges: %s has edges but no vertexes, cannot fix\n", loadmodel->name); + out->v[0] = 0; out->v[1] = 0; } @@ -1996,7 +2068,7 @@ static void Mod_Q1BSP_LoadTexinfo(lump_t *l) { // if texture chosen is NULL or the shader needs a lightmap, // force to notexture water shader - if (out->texture == NULL || out->texture->basematerialflags & MATERIALFLAG_WALL) + if (out->texture == NULL) out->texture = loadmodel->data_textures + (loadmodel->num_textures - 1); } else @@ -2160,47 +2232,14 @@ static void Mod_Q1BSP_GenerateWarpMesh(msurface_t *surface) } #endif -static qboolean Mod_Q1BSP_AllocLightmapBlock(int *lineused, int totalwidth, int totalheight, int blockwidth, int blockheight, int *outx, int *outy) -{ - 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 - return true; -} - -extern cvar_t gl_max_size; +extern cvar_t gl_max_lightmapsize; 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, lightmapsize, totallightmapsamples; float texmins[2], texmaxs[2], val; -#define LIGHTMAPSIZE 1024 rtexture_t *lightmaptexture, *deluxemaptexture; - int lightmap_lineused[LIGHTMAPSIZE]; in = (dface_t *)(mod_base + l->fileofs); if (l->filelen % sizeof(*in)) @@ -2211,6 +2250,8 @@ static void Mod_Q1BSP_LoadFaces(lump_t *l) loadmodel->num_surfaces = count; + loadmodel->brushq1.lightmapupdateflags = (unsigned char *)Mem_Alloc(loadmodel->mempool, count*sizeof(unsigned char)); + totalverts = 0; totaltris = 0; for (surfacenum = 0, in = (dface_t *)(mod_base + l->fileofs);surfacenum < count;surfacenum++, in++) @@ -2225,7 +2266,7 @@ static void Mod_Q1BSP_LoadFaces(lump_t *l) lightmaptexture = NULL; deluxemaptexture = r_texture_blanknormalmap; lightmapnumber = 1; - lightmapsize = bound(256, gl_max_size.integer, LIGHTMAPSIZE); + lightmapsize = bound(256, gl_max_lightmapsize.integer, (int)vid.maxtexturesize_2d); totallightmapsamples = 0; totalverts = 0; @@ -2266,7 +2307,8 @@ static void Mod_Q1BSP_LoadFaces(lump_t *l) { int lindex = loadmodel->brushq1.surfedges[firstedge + i]; float s, t; - if (lindex > 0) + // note: the q1bsp format does not allow a 0 surfedge (it would have no negative counterpart) + if (lindex >= 0) VectorCopy(loadmodel->brushq1.vertexes[loadmodel->brushq1.edges[lindex].v[0]].position, (loadmodel->surfmesh.data_vertex3f + 3 * surface->num_firstvertex) + i * 3); else VectorCopy(loadmodel->brushq1.vertexes[loadmodel->brushq1.edges[-lindex].v[1]].position, (loadmodel->surfmesh.data_vertex3f + 3 * surface->num_firstvertex) + i * 3); @@ -2323,13 +2365,15 @@ static void Mod_Q1BSP_LoadFaces(lump_t *l) if (i == -1) { surface->lightmapinfo->samples = NULL; +#if 1 // 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; memset(surface->lightmapinfo->samples, 128, ssize * tsize * 3); } +#endif } else if (loadmodel->brush.ishlbsp) // LordHavoc: HalfLife map (bsp version 30) surface->lightmapinfo->samples = loadmodel->brushq1.lightdata + i; @@ -2358,82 +2402,100 @@ static void Mod_Q1BSP_LoadFaces(lump_t *l) // additionally this is used by the later code to see if a // lightmap is needed on this surface (rather than duplicating the // logic above) - surface->cached_dlight = true; + 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 + // trying to max out the 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) - // and finally, limit it to the size of our lineused array i = lightmapsize; - for (lightmapsize = 64;lightmapsize < LIGHTMAPSIZE && (lightmapsize < i || (lightmapsize < gl_max_size.integer && totallightmapsamples*2 > lightmapsize*lightmapsize));lightmapsize*=2) + for (lightmapsize = 64; (lightmapsize < i) && (lightmapsize < bound(128, gl_max_lightmapsize.integer, (int)vid.maxtexturesize_2d)) && (totallightmapsamples > lightmapsize*lightmapsize); lightmapsize*=2) ; // now that we've decided the lightmap texture size, we can do the rest if (cls.state != ca_dedicated) { + int stainmapsize = 0; + mod_alloclightmap_state_t allocState; + + Mod_AllocLightmap_Init(&allocState, lightmapsize, lightmapsize); for (surfacenum = 0, surface = loadmodel->data_surfaces;surfacenum < count;surfacenum++, surface++) { - // check if we should apply a lightmap to this - if (surface->cached_dlight) - { - int i, iu, iv, lightmapx, lightmapy; - float u, v, ubase, vbase, uscale, vscale; + 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 (!loadmodel->brushq1.lightmapupdateflags[surfacenum]) + continue; - // 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); + 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; + stainmapsize += ssize * tsize * 3; - // find a place for this lightmap - if (!lightmaptexture || !Mod_Q1BSP_AllocLightmapBlock(lightmap_lineused, lightmapsize, lightmapsize, ssize, tsize, &lightmapx, &lightmapy)) - { - // allocate a texture pool if we need it - if (loadmodel->texturepool == NULL) - loadmodel->texturepool = R_AllocTexturePool(); - // could not find room, make a new lightmap - lightmaptexture = R_LoadTexture2D(loadmodel->texturepool, va("lightmap%i", lightmapnumber), lightmapsize, lightmapsize, NULL, loadmodel->brushq1.lightmaprgba ? TEXTYPE_RGBA : TEXTYPE_RGB, TEXF_FORCELINEAR | TEXF_PRECACHE, NULL); - 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); - lightmapnumber++; - memset(lightmap_lineused, 0, sizeof(lightmap_lineused)); - Mod_Q1BSP_AllocLightmapBlock(lightmap_lineused, lightmapsize, lightmapsize, ssize, tsize, &lightmapx, &lightmapy); - } + if (!lightmaptexture || !Mod_AllocLightmap_Block(&allocState, ssize, tsize, &lightmapx, &lightmapy)) + { + // allocate a texture pool if we need it + if (loadmodel->texturepool == NULL) + loadmodel->texturepool = R_AllocTexturePool(); + // could not find room, make a new lightmap + lightmaptexture = R_LoadTexture2D(loadmodel->texturepool, va("lightmap%i", lightmapnumber), lightmapsize, lightmapsize, NULL, TEXTYPE_BGRA, TEXF_FORCELINEAR | TEXF_PRECACHE, NULL); + if (loadmodel->brushq1.nmaplightdata) + deluxemaptexture = R_LoadTexture2D(loadmodel->texturepool, va("deluxemap%i", lightmapnumber), lightmapsize, lightmapsize, NULL, TEXTYPE_BGRA, TEXF_FORCELINEAR | TEXF_PRECACHE, NULL); + lightmapnumber++; + Mod_AllocLightmap_Reset(&allocState); + Mod_AllocLightmap_Block(&allocState, ssize, tsize, &lightmapx, &lightmapy); + } + surface->lightmaptexture = lightmaptexture; + surface->deluxemaptexture = deluxemaptexture; + surface->lightmapinfo->lightmaporigin[0] = lightmapx; + surface->lightmapinfo->lightmaporigin[1] = lightmapy; - surface->lightmaptexture = lightmaptexture; - surface->deluxemaptexture = deluxemaptexture; - surface->lightmapinfo->lightmaporigin[0] = lightmapx; - surface->lightmapinfo->lightmaporigin[1] = lightmapy; + uscale = 1.0f / (float)lightmapsize; + vscale = 1.0f / (float)lightmapsize; + ubase = lightmapx * uscale; + vbase = lightmapy * vscale; - uscale = 1.0f / (float)lightmapsize; - vscale = 1.0f / (float)lightmapsize; - ubase = lightmapx * uscale; - vbase = lightmapy * vscale; + for (i = 0;i < surface->num_vertices;i++) + { + u = ((DotProduct(((loadmodel->surfmesh.data_vertex3f + 3 * surface->num_firstvertex) + i * 3), surface->lightmapinfo->texinfo->vecs[0]) + surface->lightmapinfo->texinfo->vecs[0][3]) + 8 - surface->lightmapinfo->texturemins[0]) * (1.0 / 16.0); + v = ((DotProduct(((loadmodel->surfmesh.data_vertex3f + 3 * surface->num_firstvertex) + i * 3), surface->lightmapinfo->texinfo->vecs[1]) + surface->lightmapinfo->texinfo->vecs[1][3]) + 8 - surface->lightmapinfo->texturemins[1]) * (1.0 / 16.0); + (loadmodel->surfmesh.data_texcoordlightmap2f + 2 * surface->num_firstvertex)[i * 2 + 0] = u * uscale + ubase; + (loadmodel->surfmesh.data_texcoordlightmap2f + 2 * surface->num_firstvertex)[i * 2 + 1] = v * vscale + vbase; + // LordHavoc: calc lightmap data offset for vertex lighting to use + iu = (int) u; + iv = (int) v; + (loadmodel->surfmesh.data_lightmapoffsets + surface->num_firstvertex)[i] = (bound(0, iv, tmax) * ssize + bound(0, iu, smax)) * 3; + } + } - for (i = 0;i < surface->num_vertices;i++) - { - u = ((DotProduct(((loadmodel->surfmesh.data_vertex3f + 3 * surface->num_firstvertex) + i * 3), surface->lightmapinfo->texinfo->vecs[0]) + surface->lightmapinfo->texinfo->vecs[0][3]) + 8 - surface->lightmapinfo->texturemins[0]) * (1.0 / 16.0); - v = ((DotProduct(((loadmodel->surfmesh.data_vertex3f + 3 * surface->num_firstvertex) + i * 3), surface->lightmapinfo->texinfo->vecs[1]) + surface->lightmapinfo->texinfo->vecs[1][3]) + 8 - surface->lightmapinfo->texturemins[1]) * (1.0 / 16.0); - (loadmodel->surfmesh.data_texcoordlightmap2f + 2 * surface->num_firstvertex)[i * 2 + 0] = u * uscale + ubase; - (loadmodel->surfmesh.data_texcoordlightmap2f + 2 * surface->num_firstvertex)[i * 2 + 1] = v * vscale + vbase; - // LordHavoc: calc lightmap data offset for vertex lighting to use - iu = (int) u; - 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 and clear white + unsigned char *stainsamples = NULL; + 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++) + { + if (!loadmodel->brushq1.lightmapupdateflags[surfacenum]) + continue; + 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) @@ -2573,7 +2635,7 @@ static void Mod_Q1BSP_LoadLeafs(lump_t *l) 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) + if ((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; @@ -2606,11 +2668,14 @@ qboolean Mod_Q1BSP_CheckWaterAlphaSupport(void) int i, j; mleaf_t *leaf; const unsigned char *pvs; + // if there's no vis data, assume supported (because everything is visible all the time) + if (!loadmodel->brush.data_pvsclusters) + return true; // check all liquid leafs to see if they can see into empty leafs, if any // can we can assume this map supports r_wateralpha for (i = 0, leaf = loadmodel->brush.data_leafs;i < loadmodel->brush.num_leafs;i++, leaf++) { - if ((leaf->contents == CONTENTS_WATER || leaf->contents == CONTENTS_SLIME) && (leaf->clusterindex >= 0 && loadmodel->brush.data_pvsclusters)) + if ((leaf->contents == CONTENTS_WATER || leaf->contents == CONTENTS_SLIME) && leaf->clusterindex >= 0) { pvs = loadmodel->brush.data_pvsclusters + leaf->clusterindex * loadmodel->brush.num_pvsclusterbytes; for (j = 0;j < loadmodel->brush.num_leafs;j++) @@ -2637,7 +2702,7 @@ static void Mod_Q1BSP_LoadClipnodes(lump_t *l, hullinfo_t *hullinfo) 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; @@ -2863,26 +2928,7 @@ typedef struct portal_s } portal_t; -static portal_t *portalchain; - -/* -=========== -AllocPortal -=========== -*/ -static portal_t *AllocPortal(void) -{ - portal_t *p; - p = (portal_t *)Mem_Alloc(loadmodel->mempool, sizeof(portal_t)); - p->chain = portalchain; - portalchain = p; - return p; -} - -static void FreePortal(portal_t *p) -{ - Mem_Free(p); -} +static memexpandablearray_t portalarray; static void Mod_Q1BSP_RecursiveRecalcNodeBBox(mnode_t *node) { @@ -2905,8 +2951,8 @@ static void Mod_Q1BSP_RecursiveRecalcNodeBBox(mnode_t *node) static void Mod_Q1BSP_FinalizePortals(void) { - int i, j, numportals, numpoints; - portal_t *p, *pnext; + int i, j, numportals, numpoints, portalindex, portalrange = Mem_ExpandableArray_IndexRange(&portalarray); + portal_t *p; mportal_t *portal; mvertex_t *point; mleaf_t *leaf, *endleaf; @@ -2920,11 +2966,13 @@ static void Mod_Q1BSP_FinalizePortals(void) VectorSet(leaf->mins, 2000000000, 2000000000, 2000000000); VectorSet(leaf->maxs, -2000000000, -2000000000, -2000000000); } - p = portalchain; numportals = 0; numpoints = 0; - while (p) + for (portalindex = 0;portalindex < portalrange;portalindex++) { + p = (portal_t*)Mem_ExpandableArray_RecordAtIndex(&portalarray, portalindex); + if (!p) + continue; // note: this check must match the one below or it will usually corrupt memory // the nodes[0] != nodes[1] check is because leaf 0 is the shared solid leaf, it can have many portals inside with leaf 0 on both sides if (p->numpoints >= 3 && p->nodes[0] != p->nodes[1] && ((mleaf_t *)p->nodes[0])->clusterindex >= 0 && ((mleaf_t *)p->nodes[1])->clusterindex >= 0) @@ -2932,7 +2980,6 @@ static void Mod_Q1BSP_FinalizePortals(void) numportals += 2; numpoints += p->numpoints * 2; } - p = p->chain; } loadmodel->brush.data_portals = (mportal_t *)Mem_Alloc(loadmodel->mempool, numportals * sizeof(mportal_t) + numpoints * sizeof(mvertex_t)); loadmodel->brush.num_portals = numportals; @@ -2944,12 +2991,11 @@ static void Mod_Q1BSP_FinalizePortals(void) // process all portals in the global portal chain, while freeing them portal = loadmodel->brush.data_portals; point = loadmodel->brush.data_portalpoints; - p = portalchain; - portalchain = NULL; - while (p) + for (portalindex = 0;portalindex < portalrange;portalindex++) { - pnext = p->chain; - + p = (portal_t*)Mem_ExpandableArray_RecordAtIndex(&portalarray, portalindex); + if (!p) + continue; if (p->numpoints >= 3 && p->nodes[0] != p->nodes[1]) { // note: this check must match the one above or it will usually corrupt memory @@ -3017,11 +3063,9 @@ static void Mod_Q1BSP_FinalizePortals(void) } } } - FreePortal(p); - p = pnext; } // now recalculate the node bounding boxes from the leafs - Mod_Q1BSP_RecursiveRecalcNodeBBox(loadmodel->brush.data_nodes); + Mod_Q1BSP_RecursiveRecalcNodeBBox(loadmodel->brush.data_nodes + loadmodel->brushq1.hulls[0].firstclipnode); } /* @@ -3120,7 +3164,7 @@ static void Mod_Q1BSP_RecursiveNodePortals(mnode_t *node) // create the new portal by generating a polygon for the node plane, // and clipping it by all of the other portals(which came from nodes above this one) - nodeportal = AllocPortal(); + nodeportal = (portal_t *)Mem_ExpandableArray_AllocRecord(&portalarray); nodeportal->plane = *plane; // TODO: calculate node bounding boxes during recursion and calculate a maximum plane size accordingly to improve precision (as most maps do not need 1 billion unit plane polygons) @@ -3203,7 +3247,7 @@ static void Mod_Q1BSP_RecursiveNodePortals(mnode_t *node) } // the portal is split - splitportal = AllocPortal(); + splitportal = (portal_t *)Mem_ExpandableArray_AllocRecord(&portalarray); temp = splitportal->chain; *splitportal = *portal; splitportal->chain = temp; @@ -3232,70 +3276,18 @@ static void Mod_Q1BSP_RecursiveNodePortals(mnode_t *node) static void Mod_Q1BSP_MakePortals(void) { - portalchain = NULL; - Mod_Q1BSP_RecursiveNodePortals(loadmodel->brush.data_nodes); + Mem_ExpandableArray_NewArray(&portalarray, loadmodel->mempool, sizeof(portal_t), 1020*1024/sizeof(portal_t)); + Mod_Q1BSP_RecursiveNodePortals(loadmodel->brush.data_nodes + loadmodel->brushq1.hulls[0].firstclipnode); 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; - } + Mem_ExpandableArray_FreeArray(&portalarray); } //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; + node = model->brush.data_nodes + model->brushq1.hulls[0].firstclipnode; while (node->plane) node = node->children[(node->plane->type < 3 ? p[node->plane->type] : DotProduct(p,node->plane->normal)) < node->plane->dist]; if (((mleaf_t *)node)->clusterindex >= 0) @@ -3304,7 +3296,7 @@ static unsigned char *Mod_Q1BSP_GetPVS(model_t *model, const vec3_t p) return NULL; } -static void Mod_Q1BSP_FatPVS_RecursiveBSPNode(model_t *model, const vec3_t org, vec_t radius, unsigned char *pvsbuffer, int pvsbytes, mnode_t *node) +static void Mod_Q1BSP_FatPVS_RecursiveBSPNode(dp_model_t *model, const vec3_t org, vec_t radius, unsigned char *pvsbuffer, int pvsbytes, mnode_t *node) { while (node->plane) { @@ -3332,7 +3324,7 @@ static void Mod_Q1BSP_FatPVS_RecursiveBSPNode(model_t *model, const vec3_t org, //Calculates a PVS that is the inclusive or of all leafs within radius pixels //of the given point. -static int Mod_Q1BSP_FatPVS(model_t *model, const vec3_t org, vec_t radius, unsigned char *pvsbuffer, int pvsbufferlength, qboolean merge) +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); @@ -3343,26 +3335,17 @@ static int Mod_Q1BSP_FatPVS(model_t *model, const vec3_t org, vec_t radius, unsi } if (!merge) memset(pvsbuffer, 0, bytes); - Mod_Q1BSP_FatPVS_RecursiveBSPNode(model, org, radius, pvsbuffer, bytes, model->brush.data_nodes); + Mod_Q1BSP_FatPVS_RecursiveBSPNode(model, org, radius, pvsbuffer, bytes, model->brush.data_nodes + model->brushq1.hulls[0].firstclipnode); 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 @@ -3389,113 +3372,68 @@ static void Mod_Q1BSP_RoundUpToHullSize(model_t *cmodel, const vec3_t inmins, co VectorAdd(inmins, hull->clip_size, outmaxs); } -void Mod_Q1BSP_Load(model_t *mod, void *buffer, void *bufferend) +void Mod_Q1BSP_Load(dp_model_t *mod, void *buffer, void *bufferend) { int i, j, k; dheader_t *header; dmodel_t *bm; mempool_t *mainmempool; - float dist, modelyawradius, modelradius, *vec; + float dist, modelyawradius, modelradius; 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->modeldatatypestring = "Q1BSP"; mod->type = mod_brushq1; - if (!memcmp (buffer, "MCBSPpad", 8)) - { - unsigned char *index; - - mod->brush.ismcbsp = true; - mod->brush.ishlbsp = false; - - mod_base = (unsigned char*)buffer; - - 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); - - // read hull info - hullinfo.numhulls = SB_ReadInt (&index); - hullinfo.filehulls = hullinfo.numhulls; - mod->brushq1.numhulls = hullinfo.numhulls; + header = (dheader_t *)buffer; - 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) - { - mod->modeldatatypestring = "HLBSP"; - - hullinfo.numhulls = 4; - hullinfo.filehulls = 4; - mod->brushq1.numhulls = 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; - mod->brushq1.numhulls = 3; - 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->TraceLine = Mod_Q1BSP_TraceLine; + mod->TracePoint = Mod_Q1BSP_TracePoint; + mod->PointSuperContents = Mod_Q1BSP_PointSuperContents; mod->brush.TraceLineOfSight = Mod_Q1BSP_TraceLineOfSight; mod->brush.SuperContentsFromNativeContents = Mod_Q1BSP_SuperContentsFromNativeContents; mod->brush.NativeContentsFromSuperContents = Mod_Q1BSP_NativeContentsFromSuperContents; @@ -3510,18 +3448,19 @@ void Mod_Q1BSP_Load(model_t *mod, void *buffer, void *bufferend) mod->brush.AmbientSoundLevelsForPoint = Mod_Q1BSP_AmbientSoundLevelsForPoint; mod->brush.RoundUpToHullSize = Mod_Q1BSP_RoundUpToHullSize; mod->brush.PointInLeaf = Mod_Q1BSP_PointInLeaf; - - if (loadmodel->isworldmodel) - { - Cvar_SetValue("halflifebsp", mod->brush.ishlbsp); - Cvar_SetValue("mcbsp", mod->brush.ismcbsp); - } + mod->Draw = R_Q1BSP_Draw; + mod->DrawDepth = R_Q1BSP_DrawDepth; + mod->DrawDebug = R_Q1BSP_DrawDebug; + mod->DrawPrepass = R_Q1BSP_DrawPrepass; + mod->GetLightInfo = R_Q1BSP_GetLightInfo; + mod->CompileShadowMap = R_Q1BSP_CompileShadowMap; + mod->DrawShadowMap = R_Q1BSP_DrawShadowMap; + mod->CompileShadowVolume = R_Q1BSP_CompileShadowVolume; + mod->DrawShadowVolume = R_Q1BSP_DrawShadowVolume; + mod->DrawLight = R_Q1BSP_DrawLight; // 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++) @@ -3581,15 +3520,7 @@ void Mod_Q1BSP_Load(model_t *mod, void *buffer, void *bufferend) 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: @@ -3605,6 +3536,25 @@ void Mod_Q1BSP_Load(model_t *mod, void *buffer, void *bufferend) // LordHavoc: now the explanation of my sane way (which works identically): // set up the world model, then on each submodel copy from the world model // and set up the submodel with the respective model info. + totalstylesurfaces = 0; + totalstyles = 0; + for (i = 0;i < mod->brush.numsubmodels;i++) + { + memset(stylecounts, 0, sizeof(stylecounts)); + for (k = 0;k < mod->brushq1.submodels[i].numfaces;k++) + { + surface = mod->data_surfaces + mod->brushq1.submodels[i].firstface + k; + for (j = 0;j < MAXLIGHTMAPS;j++) + stylecounts[surface->lightmapinfo->styles[j]]++; + } + for (k = 0;k < 255;k++) + { + totalstyles++; + if (stylecounts[k]) + totalstylesurfaces += stylecounts[k]; + } + } + datapointer = (unsigned char *)Mem_Alloc(mod->mempool, mod->num_surfaces * sizeof(int) + totalstyles * sizeof(model_brush_lightstyleinfo_t) + totalstylesurfaces * sizeof(int *)); for (i = 0;i < mod->brush.numsubmodels;i++) { // LordHavoc: this code was originally at the end of this loop, but @@ -3613,21 +3563,25 @@ void Mod_Q1BSP_Load(model_t *mod, void *buffer, void *bufferend) if (i > 0) { char name[10]; - // LordHavoc: only register submodels if it is the world - // (prevents external bsp models from replacing world submodels with - // their own) - if (!loadmodel->isworldmodel) - continue; // duplicate the basic information - sprintf(name, "*%i", i); - mod = Mod_FindName(name); + dpsnprintf(name, sizeof(name), "*%i", i); + mod = Mod_FindName(name, loadmodel->name); // copy the base model to this one *mod = *loadmodel; // rename the clone back to its proper name strlcpy(mod->name, name, sizeof(mod->name)); + mod->brush.parentmodel = loadmodel; // textures and memory belong to the main model mod->texturepool = NULL; mod->mempool = NULL; + mod->brush.GetPVS = NULL; + mod->brush.FatPVS = NULL; + mod->brush.BoxTouchingPVS = NULL; + mod->brush.BoxTouchingLeafPVS = NULL; + mod->brush.BoxTouchingVisibleLeafs = NULL; + mod->brush.FindBoxClusters = NULL; + mod->brush.LightPoint = NULL; + mod->brush.AmbientSoundLevelsForPoint = NULL; } mod->brush.submodel = i; @@ -3647,74 +3601,90 @@ void Mod_Q1BSP_Load(model_t *mod, void *buffer, void *bufferend) mod->firstmodelsurface = bm->firstface; mod->nummodelsurfaces = bm->numfaces; + // set node/leaf parents for this submodel + Mod_Q1BSP_LoadNodes_RecursiveSetParent(mod->brush.data_nodes + mod->brushq1.hulls[0].firstclipnode, NULL); + // make the model surface list (used by shadowing/lighting) - mod->surfacelist = (int *)Mem_Alloc(loadmodel->mempool, mod->nummodelsurfaces * sizeof(*mod->surfacelist)); - for (j = 0;j < mod->nummodelsurfaces;j++) - mod->surfacelist[j] = mod->firstmodelsurface + j; + mod->sortedmodelsurfaces = (int *)datapointer;datapointer += mod->nummodelsurfaces * sizeof(int); + Mod_MakeSortedSurfaces(mod); + + // copy the submodel bounds, then enlarge the yaw and rotated bounds according to radius + // (previously this code measured the radius of the vertices of surfaces in the submodel, but that broke submodels that contain only CLIP brushes, which do not produce surfaces) + VectorCopy(bm->mins, mod->normalmins); + VectorCopy(bm->maxs, mod->normalmaxs); + dist = max(fabs(mod->normalmins[0]), fabs(mod->normalmaxs[0])); + modelyawradius = max(fabs(mod->normalmins[1]), fabs(mod->normalmaxs[1])); + modelyawradius = dist*dist+modelyawradius*modelyawradius; + modelradius = max(fabs(mod->normalmins[2]), fabs(mod->normalmaxs[2])); + modelradius = modelyawradius + modelradius * modelradius; + modelyawradius = sqrt(modelyawradius); + modelradius = sqrt(modelradius); + mod->yawmins[0] = mod->yawmins[1] = -modelyawradius; + mod->yawmins[2] = mod->normalmins[2]; + mod->yawmaxs[0] = mod->yawmaxs[1] = modelyawradius; + 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->radius = modelradius; + mod->radius2 = modelradius * modelradius; // 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->DrawLight = R_Q1BSP_DrawLight; - if (i != 0) - { - mod->brush.TraceLineOfSight = NULL; - mod->brush.GetPVS = NULL; - mod->brush.FatPVS = NULL; - mod->brush.BoxTouchingPVS = NULL; - mod->brush.BoxTouchingLeafPVS = NULL; - mod->brush.BoxTouchingVisibleLeafs = NULL; - mod->brush.FindBoxClusters = NULL; - mod->brush.LightPoint = NULL; - mod->brush.AmbientSoundLevelsForPoint = NULL; - } - Mod_Q1BSP_BuildLightmapUpdateChains(loadmodel->mempool, mod); + + // scan surfaces for sky and water and flag the submodel as possessing these features or not + // build lightstyle lists for quick marking of dirty lightmaps when lightstyles flicker 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; + break; + if (j < mod->nummodelsurfaces) + mod->DrawSky = R_Q1BSP_DrawSky; + + for (j = 0, surface = &mod->data_surfaces[mod->firstmodelsurface];j < mod->nummodelsurfaces;j++, surface++) 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) + break; + if (j < mod->nummodelsurfaces) + mod->DrawAddWaterPlanes = R_Q1BSP_DrawAddWaterPlanes; + + // 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 (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; - dist += vec[2]*vec[2]; - if (modelradius < dist) - modelradius = dist; + if (surface->lightmapinfo->styles[j] != 255) + { + int r = remapstyles[surface->lightmapinfo->styles[j]]; + styleinfo[r].surfacelist[styleinfo[r].numsurfaces++] = mod->firstmodelsurface + k; + } } } - 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->radius = modelradius; - mod->radius2 = modelradius * modelradius; + 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 { @@ -4110,7 +4080,7 @@ static void Mod_Q2BSP_LoadModels(lump_t *l) */ } -void static Mod_Q2BSP_Load(model_t *mod, void *buffer, void *bufferend) +void static Mod_Q2BSP_Load(dp_model_t *mod, void *buffer, void *bufferend) { int i; q2dheader_t *header; @@ -4126,13 +4096,6 @@ void static Mod_Q2BSP_Load(model_t *mod, void *buffer, void *bufferend) i = LittleLong(header->version); 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; @@ -4140,9 +4103,6 @@ void static Mod_Q2BSP_Load(model_t *mod, void *buffer, void *bufferend) for (i = 0;i < (int) sizeof(*header) / 4;i++) ((int *)header)[i] = LittleLong(((int *)header)[i]); - // store which lightmap format to use - mod->brushq1.lightmaprgba = r_lightmaprgba.integer; - mod->brush.qw_md4sum = 0; mod->brush.qw_md4sum2 = 0; for (i = 0;i < Q2HEADER_LUMPS;i++) @@ -4176,8 +4136,8 @@ void static Mod_Q2BSP_Load(model_t *mod, void *buffer, void *bufferend) Mod_Q2BSP_LoadModels(&header->lumps[Q2LUMP_MODELS]); } -static int Mod_Q3BSP_SuperContentsFromNativeContents(model_t *model, int nativecontents); -static int Mod_Q3BSP_NativeContentsFromSuperContents(model_t *model, int supercontents); +static int Mod_Q3BSP_SuperContentsFromNativeContents(dp_model_t *model, int nativecontents); +static int Mod_Q3BSP_NativeContentsFromSuperContents(dp_model_t *model, int supercontents); static void Mod_Q3BSP_LoadEntities(lump_t *l) { @@ -4189,10 +4149,13 @@ static void Mod_Q3BSP_LoadEntities(lump_t *l) loadmodel->brushq3.num_lightgrid_cellsize[2] = 128; if (!l->filelen) return; - loadmodel->brush.entities = (char *)Mem_Alloc(loadmodel->mempool, l->filelen); + loadmodel->brush.entities = (char *)Mem_Alloc(loadmodel->mempool, l->filelen + 1); memcpy(loadmodel->brush.entities, mod_base + l->fileofs, l->filelen); + loadmodel->brush.entities[l->filelen] = 0; data = loadmodel->brush.entities; // some Q3 maps override the lightgrid_cellsize with a worldspawn key + // VorteX: q3map2 FS-R generates tangentspace deluxemaps for q3bsp and sets 'deluxeMaps' key + loadmodel->brushq3.deluxemapping = false; if (data && COM_ParseToken_Simple(&data, false, false) && com_token[0] == '{') { while (1) @@ -4210,10 +4173,34 @@ static void Mod_Q3BSP_LoadEntities(lump_t *l) if (!COM_ParseToken_Simple(&data, false, false)) break; // error strlcpy(value, com_token, sizeof(value)); - if (!strcmp("gridsize", key)) + if (!strcasecmp("gridsize", key)) // this one is case insensitive to 100% match q3map2 { +#if _MSC_VER >= 1400 +#define sscanf sscanf_s +#endif +#if 0 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); +#else + VectorSet(v, 64, 64, 128); + if(sscanf(value, "%f %f %f", &v[0], &v[1], &v[2]) != 3) + Con_Printf("Mod_Q3BSP_LoadEntities: funny gridsize \"%s\" in %s, interpreting as \"%f %f %f\" to match q3map2's parsing\n", value, loadmodel->name, v[0], v[1], v[2]); + if (v[0] != 0 && v[1] != 0 && v[2] != 0) + VectorCopy(v, loadmodel->brushq3.num_lightgrid_cellsize); +#endif + } + else if (!strcmp("deluxeMaps", key)) + { + if (!strcmp(com_token, "1")) + { + loadmodel->brushq3.deluxemapping = true; + loadmodel->brushq3.deluxemapping_modelspace = true; + } + else if (!strcmp(com_token, "2")) + { + loadmodel->brushq3.deluxemapping = true; + loadmodel->brushq3.deluxemapping_modelspace = false; + } } } } @@ -4223,7 +4210,7 @@ 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)) @@ -4245,12 +4232,8 @@ static void Mod_Q3BSP_LoadTextures(lump_t *l) if (cls.state == ca_dedicated) return; - c = 0; for (i = 0;i < count;i++, in++, out++) - if (!Mod_LoadTextureFromQ3Shader(out, out->name, false, true, false)) - c++; - 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) @@ -4306,11 +4289,39 @@ static void Mod_Q3BSP_LoadBrushSides(lump_t *l) } } +static void Mod_Q3BSP_LoadBrushSides_IG(lump_t *l) +{ + q3dbrushside_ig_t *in; + q3mbrushside_t *out; + int i, n, count; + + in = (q3dbrushside_ig_t *)(mod_base + l->fileofs); + if (l->filelen % sizeof(*in)) + Host_Error("Mod_Q3BSP_LoadBrushSides: funny lump size in %s",loadmodel->name); + count = l->filelen / sizeof(*in); + out = (q3mbrushside_t *)Mem_Alloc(loadmodel->mempool, count * sizeof(*out)); + + loadmodel->brush.data_brushsides = out; + loadmodel->brush.num_brushsides = count; + + for (i = 0;i < count;i++, in++, out++) + { + n = LittleLong(in->planeindex); + if (n < 0 || n >= loadmodel->brush.num_planes) + Host_Error("Mod_Q3BSP_LoadBrushSides: invalid planeindex %i (%i planes)", n, loadmodel->brush.num_planes); + out->plane = loadmodel->brush.data_planes + n; + n = LittleLong(in->textureindex); + if (n < 0 || n >= loadmodel->num_textures) + Host_Error("Mod_Q3BSP_LoadBrushSides: invalid textureindex %i (%i textures)", n, loadmodel->num_textures); + out->texture = loadmodel->data_textures + n; + } +} + static void Mod_Q3BSP_LoadBrushes(lump_t *l) { q3dbrush_t *in; q3mbrush_t *out; - int i, j, n, c, count, maxplanes; + int i, j, n, c, count, maxplanes, q3surfaceflags; colplanef_t *planes; in = (q3dbrush_t *)(mod_base + l->fileofs); @@ -4346,15 +4357,20 @@ static void Mod_Q3BSP_LoadBrushes(lump_t *l) Mem_Free(planes); planes = (colplanef_t *)Mem_Alloc(tempmempool, sizeof(colplanef_t) * maxplanes); } + q3surfaceflags = 0; for (j = 0;j < out->numbrushsides;j++) { VectorCopy(out->firstbrushside[j].plane->normal, planes[j].normal); planes[j].dist = out->firstbrushside[j].plane->dist; planes[j].q3surfaceflags = out->firstbrushside[j].texture->surfaceflags; planes[j].texture = out->firstbrushside[j].texture; + q3surfaceflags |= planes[j].q3surfaceflags; } // make the colbrush from the planes - out->colbrushf = Collision_NewBrushFromPlanes(loadmodel->mempool, out->numbrushsides, planes, out->texture->supercontents); + out->colbrushf = Collision_NewBrushFromPlanes(loadmodel->mempool, out->numbrushsides, planes, out->texture->supercontents, q3surfaceflags, out->texture, true); + + // this whole loop can take a while (e.g. on redstarrepublic4) + CL_KeepaliveMessage(false); } if (planes) Mem_Free(planes); @@ -4445,6 +4461,8 @@ static void Mod_Q3BSP_LoadTriangles(lump_t *l) if (*out < 0 || *out >= loadmodel->brushq3.num_vertices) { Con_Printf("Mod_Q3BSP_LoadTriangles: invalid vertexindex %i (%i vertices), setting to 0\n", *out, loadmodel->brushq3.num_vertices); + if(!loadmodel->brushq3.num_vertices) + Host_Error("Mod_Q1BSP_LoadTrianglles: %s has triangles but no vertexes, cannot fix\n", loadmodel->name); *out = 0; } } @@ -4452,18 +4470,85 @@ static void Mod_Q3BSP_LoadTriangles(lump_t *l) static void Mod_Q3BSP_LoadLightmaps(lump_t *l, lump_t *faceslump) { - q3dlightmap_t *in; - int i, j, count, power, power2, mask, endlightmap, mergewidth, mergeheight; + 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); + + if(mod_q3bsp_nolightmaps.integer) + { + return; + } + else if(l->filelen) + { + // prefer internal LMs for compatibility (a BSP contains no info on whether external LMs exist) + if (developer_loading.integer) + Con_Printf("Using internal lightmaps\n"); + 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; + } + else + { + // no internal lightmaps + // try external lightmaps + if (developer_loading.integer) + Con_Printf("Using external lightmaps\n"); + FS_StripExtension(loadmodel->name, mapname, sizeof(mapname)); + inpixels[0] = loadimagepixelsbgra(va("%s/lm_%04d", mapname, 0), false, false); + if(!inpixels[0]) + return; + + // 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); + } + } + } + + convertedpixels = (unsigned char *) Mem_Alloc(tempmempool, size*size*4); + loadmodel->brushq3.lightmapsize = size; loadmodel->brushq3.num_originallightmaps = count; // now check the surfaces to see if any of them index an odd numbered @@ -4475,56 +4560,75 @@ static void Mod_Q3BSP_LoadLightmaps(lump_t *l, lump_t *faceslump) // 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. - loadmodel->brushq3.deluxemapping = !(count & 1); - loadmodel->brushq3.deluxemapping_modelspace = true; - endlightmap = 0; - if (loadmodel->brushq3.deluxemapping) - { - int facecount = faceslump->filelen / sizeof(q3dface_t); - q3dface_t *faces = (q3dface_t *)(mod_base + faceslump->fileofs); - for (i = 0;i < facecount;i++) - { - j = LittleLong(faces[i].lightmapindex); - if (j >= 0) + // VorteX: autodetect only if previous attempt to find "deluxeMaps" key + // in Mod_Q3BSP_LoadEntities was failed + if (!loadmodel->brushq3.deluxemapping) + { + loadmodel->brushq3.deluxemapping = !(count & 1); + loadmodel->brushq3.deluxemapping_modelspace = true; + endlightmap = 0; + if (loadmodel->brushq3.deluxemapping) + { + int facecount = faceslump->filelen / sizeof(q3dface_t); + q3dface_t *faces = (q3dface_t *)(mod_base + faceslump->fileofs); + for (i = 0;i < facecount;i++) { - endlightmap = max(endlightmap, j + 1); - if ((j & 1) || j + 1 >= count) + j = LittleLong(faces[i].lightmapindex); + if (j >= 0) { - loadmodel->brushq3.deluxemapping = false; - break; + endlightmap = max(endlightmap, j + 1); + if ((j & 1) || j + 1 >= count) + { + loadmodel->brushq3.deluxemapping = false; + break; + } } } } - } - 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) - { - c = in[1].rgb; - for (i = 0;i < 128*128*3;i++) - if (c[i]) - break; - if (i == 128*128*3) + // 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. + // + // 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) { - // all pixels in the unused lightmap were black... - loadmodel->brushq3.deluxemapping = false; + 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 == size*size) + { + // all pixels in the unused lightmap were black... + loadmodel->brushq3.deluxemapping = false; + } } } Con_DPrintf("%s is %sdeluxemapped\n", loadmodel->name, loadmodel->brushq3.deluxemapping ? "" : "not "); // figure out what the most reasonable merge power is within limits + loadmodel->brushq3.num_lightmapmergepower = 0; - for (power = 1;power <= mod_q3bsp_lightmapmergepower.integer && (128 << power) <= gl_max_texture_size && (1 << (power * 2)) < 4 * (count >> loadmodel->brushq3.deluxemapping);power++) + + for(i = 0; (128 << i) < size; ++i) + ; + // i is now 0 for 128, 1 for 256, etc + + for (power = 1;power + i <= mod_q3bsp_lightmapmergepower.integer && (size << power) <= (int)vid.maxtexturesize_2d && (1 << (power * 2)) < 4 * (count >> (loadmodel->brushq3.deluxemapping ? 1 : 0)); power++) loadmodel->brushq3.num_lightmapmergepower = power; + 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); + loadmodel->brushq3.num_mergedlightmaps = ((count >> (loadmodel->brushq3.deluxemapping ? 1 : 0)) + (1 << (loadmodel->brushq3.num_lightmapmergepower * 2)) - 1) >> (loadmodel->brushq3.num_lightmapmergepower * 2); loadmodel->brushq3.data_lightmaps = (rtexture_t **)Mem_Alloc(loadmodel->mempool, loadmodel->brushq3.num_mergedlightmaps * sizeof(rtexture_t *)); if (loadmodel->brushq3.deluxemapping) loadmodel->brushq3.data_deluxemaps = (rtexture_t **)Mem_Alloc(loadmodel->mempool, loadmodel->brushq3.num_mergedlightmaps * sizeof(rtexture_t *)); @@ -4533,62 +4637,140 @@ static void Mod_Q3BSP_LoadLightmaps(lump_t *l, lump_t *faceslump) if (loadmodel->texturepool == NULL && cls.state != ca_dedicated) loadmodel->texturepool = R_AllocTexturePool(); - if (loadmodel->brushq3.num_lightmapmergepower > 0) + power = loadmodel->brushq3.num_lightmapmergepower; + power2 = power * 2; + mask = (1 << power) - 1; + for (i = 0;i < count;i++) { - power = loadmodel->brushq3.num_lightmapmergepower; - power2 = power * 2; - mask = (1 << power) - 1; - for (i = 0;i < count;i++) + // 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) { - // figure out which merged lightmap texture this fits into - int lightmapindex = i >> (loadmodel->brushq3.deluxemapping + power2); // 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 128x128 blocks + // 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); + j = (count >> (loadmodel->brushq3.deluxemapping ? 1 : 0)) - (lightmapindex << power2); for (mergewidth = 1;mergewidth < j && mergewidth < (1 << power);mergewidth *= 2) ; for (mergeheight = 1;mergewidth*mergeheight < j && mergeheight < (1 << power);mergeheight *= 2) ; - Con_DPrintf("lightmap merge texture #%i is %ix%i (%i of %i used)\n", lightmapindex, mergewidth*128, mergeheight*128, min(j, mergewidth*mergeheight), mergewidth*mergeheight); - loadmodel->brushq3.data_lightmaps[lightmapindex] = R_LoadTexture2D(loadmodel->texturepool, va("lightmap%04i", lightmapindex), mergewidth * 128, mergeheight * 128, NULL, TEXTYPE_RGB, TEXF_FORCELINEAR | TEXF_PRECACHE | (gl_texturecompression_q3bsplightmaps.integer ? TEXF_COMPRESS : 0), NULL); + 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 * 128, mergeheight * 128, NULL, TEXTYPE_RGB, TEXF_FORCELINEAR | TEXF_PRECACHE | (gl_texturecompression_q3bspdeluxemaps.integer ? TEXF_COMPRESS : 0), NULL); + 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]) / 128; - mergeheight = R_TextureHeight(loadmodel->brushq3.data_lightmaps[lightmapindex]) / 128; - j = (i >> loadmodel->brushq3.deluxemapping) & ((1 << power2) - 1); + mergewidth = R_TextureWidth(loadmodel->brushq3.data_lightmaps[lightmapindex]) / size; + mergeheight = R_TextureHeight(loadmodel->brushq3.data_lightmaps[lightmapindex]) / size; + j = (i >> (loadmodel->brushq3.deluxemapping ? 1 : 0)) & ((1 << power2) - 1); if (loadmodel->brushq3.deluxemapping && (i & 1)) - R_UpdateTexture(loadmodel->brushq3.data_deluxemaps[lightmapindex], in[i].rgb, (j % mergewidth) * 128, (j / mergewidth) * 128, 128, 128); + R_UpdateTexture(loadmodel->brushq3.data_deluxemaps[lightmapindex], convertedpixels, (j % mergewidth) * size, (j / mergewidth) * size, size, size); else - R_UpdateTexture(loadmodel->brushq3.data_lightmaps [lightmapindex], in[i].rgb, (j % mergewidth) * 128, (j / mergewidth) * 128, 128, 128); + R_UpdateTexture(loadmodel->brushq3.data_lightmaps [lightmapindex], convertedpixels, (j % mergewidth) * size, (j / mergewidth) * size, size, size); } - } - else - { - for (i = 0;i < count;i++) + else { // figure out which merged lightmap texture this fits into - int lightmapindex = i >> loadmodel->brushq3.deluxemapping; if (loadmodel->brushq3.deluxemapping && (i & 1)) - loadmodel->brushq3.data_deluxemaps[lightmapindex] = R_LoadTexture2D(loadmodel->texturepool, va("deluxemap%04i", lightmapindex), 128, 128, in[i].rgb, TEXTYPE_RGB, TEXF_FORCELINEAR | TEXF_PRECACHE | (gl_texturecompression_q3bspdeluxemaps.integer ? TEXF_COMPRESS : 0), NULL); + 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), 128, 128, in[i].rgb, TEXTYPE_RGB, TEXF_FORCELINEAR | TEXF_PRECACHE | (gl_texturecompression_q3bsplightmaps.integer ? TEXF_COMPRESS : 0), NULL); + 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); + } + } + + Mem_Free(convertedpixels); + if(external) + { + for(i = 0; i < count; ++i) + Mem_Free(inpixels[i]); + } +} + +static void Mod_Q3BSP_BuildBBoxes(const int *element3i, int num_triangles, const float *vertex3f, float **collisionbbox6f, int *collisionstride, int stride) +{ + int j, k, cnt, tri; + float *mins, *maxs; + const float *vert; + *collisionstride = stride; + if(stride > 0) + { + cnt = (num_triangles + stride - 1) / stride; + *collisionbbox6f = (float *) Mem_Alloc(loadmodel->mempool, sizeof(float[6]) * cnt); + for(j = 0; j < cnt; ++j) + { + mins = &((*collisionbbox6f)[6 * j + 0]); + maxs = &((*collisionbbox6f)[6 * j + 3]); + for(k = 0; k < stride; ++k) + { + tri = j * stride + k; + if(tri >= num_triangles) + break; + vert = &(vertex3f[element3i[3 * tri + 0] * 3]); + if(!k || vert[0] < mins[0]) mins[0] = vert[0]; + if(!k || vert[1] < mins[1]) mins[1] = vert[1]; + if(!k || vert[2] < mins[2]) mins[2] = vert[2]; + if(!k || vert[0] > maxs[0]) maxs[0] = vert[0]; + if(!k || vert[1] > maxs[1]) maxs[1] = vert[1]; + if(!k || vert[2] > maxs[2]) maxs[2] = vert[2]; + vert = &(vertex3f[element3i[3 * tri + 1] * 3]); + if(vert[0] < mins[0]) mins[0] = vert[0]; + if(vert[1] < mins[1]) mins[1] = vert[1]; + if(vert[2] < mins[2]) mins[2] = vert[2]; + if(vert[0] > maxs[0]) maxs[0] = vert[0]; + if(vert[1] > maxs[1]) maxs[1] = vert[1]; + if(vert[2] > maxs[2]) maxs[2] = vert[2]; + vert = &(vertex3f[element3i[3 * tri + 2] * 3]); + if(vert[0] < mins[0]) mins[0] = vert[0]; + if(vert[1] < mins[1]) mins[1] = vert[1]; + if(vert[2] < mins[2]) mins[2] = vert[2]; + if(vert[0] > maxs[0]) maxs[0] = vert[0]; + if(vert[1] > maxs[1]) maxs[1] = vert[1]; + if(vert[2] > maxs[2]) maxs[2] = vert[2]; + } } } + else + *collisionbbox6f = NULL; } +typedef struct patchtess_s +{ + patchinfo_t info; + + // Auxiliary data used only by patch loading code in Mod_Q3BSP_LoadFaces + int surface_id; + float lodgroup[6]; + float *originalvertex3f; +} patchtess_t; + +#define PATCHTESS_SAME_LODGROUP(a,b) \ + ( \ + (a).lodgroup[0] == (b).lodgroup[0] && \ + (a).lodgroup[1] == (b).lodgroup[1] && \ + (a).lodgroup[2] == (b).lodgroup[2] && \ + (a).lodgroup[3] == (b).lodgroup[3] && \ + (a).lodgroup[4] == (b).lodgroup[4] && \ + (a).lodgroup[5] == (b).lodgroup[5] \ + ) + static void Mod_Q3BSP_LoadFaces(lump_t *l) { q3dface_t *in, *oldin; msurface_t *out, *oldout; - int i, oldi, j, n, count, invalidelements, patchsize[2], finalwidth, finalheight, xtess, ytess, finalvertices, finaltriangles, firstvertex, firstelement, type, oldnumtriangles, oldnumtriangles2, meshvertices, meshtriangles, numvertices, numtriangles; + int i, oldi, j, n, count, invalidelements, patchsize[2], finalwidth, finalheight, xtess, ytess, finalvertices, finaltriangles, firstvertex, firstelement, type, oldnumtriangles, oldnumtriangles2, meshvertices, meshtriangles, numvertices, numtriangles, cxtess, cytess; float lightmaptcbase[2], lightmaptcscale[2]; //int *originalelement3i; //int *originalneighbor3i; @@ -4600,6 +4782,9 @@ static void Mod_Q3BSP_LoadFaces(lump_t *l) float *originaltexcoordtexture2f; float *originaltexcoordlightmap2f; float *v; + patchtess_t *patchtess = NULL; + int patchtesscount = 0; + qboolean again; in = (q3dface_t *)(mod_base + l->fileofs); if (l->filelen % sizeof(*in)) @@ -4610,6 +4795,9 @@ static void Mod_Q3BSP_LoadFaces(lump_t *l) loadmodel->data_surfaces = out; loadmodel->num_surfaces = count; + if(count > 0) + patchtess = (patchtess_t*) Mem_Alloc(tempmempool, count * sizeof(*patchtess)); + i = 0; oldi = i; oldin = in; @@ -4620,7 +4808,7 @@ static void Mod_Q3BSP_LoadFaces(lump_t *l) { // check face type first type = LittleLong(in->type); - if (type != Q3FACETYPE_POLYGON + if (type != Q3FACETYPE_FLAT && type != Q3FACETYPE_PATCH && type != Q3FACETYPE_MESH && type != Q3FACETYPE_FLARE) @@ -4657,7 +4845,8 @@ static void Mod_Q3BSP_LoadFaces(lump_t *l) n = -1; else if (n >= loadmodel->brushq3.num_originallightmaps) { - Con_Printf("Mod_Q3BSP_LoadFaces: face #%i (texture \"%s\"): invalid lightmapindex %i (%i lightmaps)\n", i, out->texture->name, n, loadmodel->brushq3.num_originallightmaps); + if(loadmodel->brushq3.num_originallightmaps != 0) + Con_Printf("Mod_Q3BSP_LoadFaces: face #%i (texture \"%s\"): invalid lightmapindex %i (%i lightmaps)\n", i, out->texture->name, n, loadmodel->brushq3.num_originallightmaps); n = -1; } else @@ -4689,7 +4878,7 @@ static void Mod_Q3BSP_LoadFaces(lump_t *l) } switch(type) { - case Q3FACETYPE_POLYGON: + case Q3FACETYPE_FLAT: case Q3FACETYPE_MESH: // no processing necessary break; @@ -4702,6 +4891,7 @@ static void Mod_Q3BSP_LoadFaces(lump_t *l) continue; } originalvertex3f = loadmodel->brushq3.data_vertex3f + firstvertex * 3; + // convert patch to Q3FACETYPE_MESH xtess = Q3PatchTesselationOnX(patchsize[0], patchsize[1], 3, originalvertex3f, r_subdivisions_tolerance.value); ytess = Q3PatchTesselationOnY(patchsize[0], patchsize[1], 3, originalvertex3f, r_subdivisions_tolerance.value); @@ -4709,20 +4899,37 @@ static void Mod_Q3BSP_LoadFaces(lump_t *l) xtess = bound(r_subdivisions_mintess.integer, xtess, r_subdivisions_maxtess.integer); ytess = bound(r_subdivisions_mintess.integer, ytess, r_subdivisions_maxtess.integer); // bound to sanity settings - xtess = bound(1, xtess, 1024); - ytess = bound(1, ytess, 1024); - // bound to user limit on vertices - while ((xtess > 1 || ytess > 1) && (((patchsize[0] - 1) * xtess) + 1) * (((patchsize[1] - 1) * ytess) + 1) > min(r_subdivisions_maxvertices.integer, 262144)) - { - if (xtess > ytess) - xtess--; - else - ytess--; - } - finalwidth = ((patchsize[0] - 1) * xtess) + 1; - finalheight = ((patchsize[1] - 1) * ytess) + 1; - numvertices = finalwidth * finalheight; - numtriangles = (finalwidth - 1) * (finalheight - 1) * 2; + xtess = bound(0, xtess, 1024); + ytess = bound(0, ytess, 1024); + + // lower quality collision patches! Same procedure as before, but different cvars + // convert patch to Q3FACETYPE_MESH + cxtess = Q3PatchTesselationOnX(patchsize[0], patchsize[1], 3, originalvertex3f, r_subdivisions_collision_tolerance.value); + cytess = Q3PatchTesselationOnY(patchsize[0], patchsize[1], 3, originalvertex3f, r_subdivisions_collision_tolerance.value); + // bound to user settings + cxtess = bound(r_subdivisions_collision_mintess.integer, cxtess, r_subdivisions_collision_maxtess.integer); + cytess = bound(r_subdivisions_collision_mintess.integer, cytess, r_subdivisions_collision_maxtess.integer); + // bound to sanity settings + cxtess = bound(0, cxtess, 1024); + cytess = bound(0, cytess, 1024); + + // store it for the LOD grouping step + patchtess[patchtesscount].info.xsize = patchsize[0]; + patchtess[patchtesscount].info.ysize = patchsize[1]; + patchtess[patchtesscount].info.lods[PATCH_LOD_VISUAL].xtess = xtess; + patchtess[patchtesscount].info.lods[PATCH_LOD_VISUAL].ytess = ytess; + patchtess[patchtesscount].info.lods[PATCH_LOD_COLLISION].xtess = cxtess; + patchtess[patchtesscount].info.lods[PATCH_LOD_COLLISION].ytess = cytess; + + patchtess[patchtesscount].surface_id = i; + patchtess[patchtesscount].lodgroup[0] = in->specific.patch.mins[0]; + patchtess[patchtesscount].lodgroup[1] = in->specific.patch.mins[1]; + patchtess[patchtesscount].lodgroup[2] = in->specific.patch.mins[2]; + patchtess[patchtesscount].lodgroup[3] = in->specific.patch.maxs[0]; + patchtess[patchtesscount].lodgroup[4] = in->specific.patch.maxs[1]; + patchtess[patchtesscount].lodgroup[5] = in->specific.patch.maxs[2]; + patchtess[patchtesscount].originalvertex3f = originalvertex3f; + ++patchtesscount; break; case Q3FACETYPE_FLARE: if (developer.integer >= 100) @@ -4736,16 +4943,48 @@ static void Mod_Q3BSP_LoadFaces(lump_t *l) meshtriangles += out->num_triangles; } - i = oldi; - in = oldin; - out = oldout; - Mod_AllocSurfMesh(loadmodel->mempool, meshvertices, meshtriangles, false, true, false); - meshvertices = 0; - meshtriangles = 0; - for (;i < count && meshvertices + out->num_vertices <= loadmodel->surfmesh.num_vertices;i++, in++, out++) + // Fix patches tesselations so that they make no seams + do { - if (out->num_vertices < 3 || out->num_triangles < 1) - continue; + again = false; + for(i = 0; i < patchtesscount; ++i) + { + for(j = i+1; j < patchtesscount; ++j) + { + if (!PATCHTESS_SAME_LODGROUP(patchtess[i], patchtess[j])) + continue; + + if (Q3PatchAdjustTesselation(3, &patchtess[i].info, patchtess[i].originalvertex3f, &patchtess[j].info, patchtess[j].originalvertex3f) ) + again = true; + } + } + } + while (again); + + // Calculate resulting number of triangles + for(i = 0; i < patchtesscount; ++i) + { + finalwidth = Q3PatchDimForTess(patchtess[i].info.xsize, patchtess[i].info.lods[PATCH_LOD_VISUAL].xtess); + finalheight = Q3PatchDimForTess(patchtess[i].info.ysize,patchtess[i].info.lods[PATCH_LOD_VISUAL].ytess); + numvertices = finalwidth * finalheight; + numtriangles = (finalwidth - 1) * (finalheight - 1) * 2; + + oldout[patchtess[i].surface_id].num_vertices = numvertices; + oldout[patchtess[i].surface_id].num_triangles = numtriangles; + meshvertices += oldout[patchtess[i].surface_id].num_vertices; + meshtriangles += oldout[patchtess[i].surface_id].num_triangles; + } + + i = oldi; + in = oldin; + out = oldout; + Mod_AllocSurfMesh(loadmodel->mempool, meshvertices, meshtriangles, false, true, false); + meshvertices = 0; + meshtriangles = 0; + for (;i < count && meshvertices + out->num_vertices <= loadmodel->surfmesh.num_vertices;i++, in++, out++) + { + if (out->num_vertices < 3 || out->num_triangles < 1) + continue; type = LittleLong(in->type); firstvertex = LittleLong(in->firstvertex); @@ -4754,7 +4993,7 @@ static void Mod_Q3BSP_LoadFaces(lump_t *l) out->num_firsttriangle = meshtriangles; switch(type) { - case Q3FACETYPE_POLYGON: + case Q3FACETYPE_FLAT: case Q3FACETYPE_MESH: // no processing necessary, except for lightmap merging for (j = 0;j < out->num_vertices;j++) @@ -4785,25 +5024,25 @@ static void Mod_Q3BSP_LoadFaces(lump_t *l) originaltexcoordtexture2f = loadmodel->brushq3.data_texcoordtexture2f + firstvertex * 2; originaltexcoordlightmap2f = loadmodel->brushq3.data_texcoordlightmap2f + firstvertex * 2; originalcolor4f = loadmodel->brushq3.data_color4f + firstvertex * 4; - // convert patch to Q3FACETYPE_MESH - xtess = Q3PatchTesselationOnX(patchsize[0], patchsize[1], 3, originalvertex3f, r_subdivisions_tolerance.value); - ytess = Q3PatchTesselationOnY(patchsize[0], patchsize[1], 3, originalvertex3f, r_subdivisions_tolerance.value); - // bound to user settings - xtess = bound(r_subdivisions_mintess.integer, xtess, r_subdivisions_maxtess.integer); - ytess = bound(r_subdivisions_mintess.integer, ytess, r_subdivisions_maxtess.integer); - // bound to sanity settings - xtess = bound(1, xtess, 1024); - ytess = bound(1, ytess, 1024); - // bound to user limit on vertices - while ((xtess > 1 || ytess > 1) && (((patchsize[0] - 1) * xtess) + 1) * (((patchsize[1] - 1) * ytess) + 1) > min(r_subdivisions_maxvertices.integer, 262144)) + + xtess = ytess = cxtess = cytess = -1; + for(j = 0; j < patchtesscount; ++j) + if(patchtess[j].surface_id == i) + { + xtess = patchtess[j].info.lods[PATCH_LOD_VISUAL].xtess; + ytess = patchtess[j].info.lods[PATCH_LOD_VISUAL].ytess; + cxtess = patchtess[j].info.lods[PATCH_LOD_COLLISION].xtess; + cytess = patchtess[j].info.lods[PATCH_LOD_COLLISION].ytess; + break; + } + if(xtess == -1) { - if (xtess > ytess) - xtess--; - else - ytess--; + Con_Printf("ERROR: patch %d isn't preprocessed?!?\n", i); + xtess = ytess = cxtess = cytess = 0; } - finalwidth = ((patchsize[0] - 1) * xtess) + 1; - finalheight = ((patchsize[1] - 1) * ytess) + 1; + + finalwidth = Q3PatchDimForTess(patchsize[0],xtess); //((patchsize[0] - 1) * xtess) + 1; + finalheight = Q3PatchDimForTess(patchsize[1],ytess); //((patchsize[1] - 1) * ytess) + 1; finalvertices = finalwidth * finalheight; finaltriangles = (finalwidth - 1) * (finalheight - 1) * 2; type = Q3FACETYPE_MESH; @@ -4815,7 +5054,9 @@ static void Mod_Q3BSP_LoadFaces(lump_t *l) Q3PatchTesselateFloat(2, sizeof(float[2]), (loadmodel->surfmesh.data_texcoordlightmap2f + 2 * out->num_firstvertex), patchsize[0], patchsize[1], sizeof(float[2]), originaltexcoordlightmap2f, xtess, ytess); Q3PatchTesselateFloat(4, sizeof(float[4]), (loadmodel->surfmesh.data_lightmapcolor4f + 4 * out->num_firstvertex), patchsize[0], patchsize[1], sizeof(float[4]), originalcolor4f, xtess, ytess); Q3PatchTriangleElements((loadmodel->surfmesh.data_element3i + 3 * out->num_firsttriangle), finalwidth, finalheight, out->num_firstvertex); + out->num_triangles = Mod_RemoveDegenerateTriangles(out->num_triangles, (loadmodel->surfmesh.data_element3i + 3 * out->num_firsttriangle), (loadmodel->surfmesh.data_element3i + 3 * out->num_firsttriangle), loadmodel->surfmesh.data_vertex3f); + if (developer.integer >= 100) { if (out->num_triangles < finaltriangles) @@ -4825,24 +5066,8 @@ static void Mod_Q3BSP_LoadFaces(lump_t *l) } // q3map does not put in collision brushes for curves... ugh // build the lower quality collision geometry - xtess = Q3PatchTesselationOnX(patchsize[0], patchsize[1], 3, originalvertex3f, r_subdivisions_collision_tolerance.value); - ytess = Q3PatchTesselationOnY(patchsize[0], patchsize[1], 3, originalvertex3f, r_subdivisions_collision_tolerance.value); - // bound to user settings - xtess = bound(r_subdivisions_collision_mintess.integer, xtess, r_subdivisions_collision_maxtess.integer); - ytess = bound(r_subdivisions_collision_mintess.integer, ytess, r_subdivisions_collision_maxtess.integer); - // bound to sanity settings - xtess = bound(1, xtess, 1024); - ytess = bound(1, ytess, 1024); - // bound to user limit on vertices - while ((xtess > 1 || ytess > 1) && (((patchsize[0] - 1) * xtess) + 1) * (((patchsize[1] - 1) * ytess) + 1) > min(r_subdivisions_collision_maxvertices.integer, 262144)) - { - if (xtess > ytess) - xtess--; - else - ytess--; - } - finalwidth = ((patchsize[0] - 1) * xtess) + 1; - finalheight = ((patchsize[1] - 1) * ytess) + 1; + finalwidth = Q3PatchDimForTess(patchsize[0],cxtess); //((patchsize[0] - 1) * cxtess) + 1; + finalheight = Q3PatchDimForTess(patchsize[1],cytess); //((patchsize[1] - 1) * cytess) + 1; finalvertices = finalwidth * finalheight; finaltriangles = (finalwidth - 1) * (finalheight - 1) * 2; @@ -4850,7 +5075,7 @@ static void Mod_Q3BSP_LoadFaces(lump_t *l) out->data_collisionelement3i = (int *)Mem_Alloc(loadmodel->mempool, sizeof(int[3]) * finaltriangles); out->num_collisionvertices = finalvertices; out->num_collisiontriangles = finaltriangles; - Q3PatchTesselateFloat(3, sizeof(float[3]), out->data_collisionvertex3f, patchsize[0], patchsize[1], sizeof(float[3]), originalvertex3f, xtess, ytess); + Q3PatchTesselateFloat(3, sizeof(float[3]), out->data_collisionvertex3f, patchsize[0], patchsize[1], sizeof(float[3]), originalvertex3f, cxtess, cytess); Q3PatchTriangleElements(out->data_collisionelement3i, finalwidth, finalheight, 0); //Mod_SnapVertices(3, out->num_vertices, (loadmodel->surfmesh.data_vertex3f + 3 * out->num_firstvertex), 0.25); @@ -4859,6 +5084,11 @@ static void Mod_Q3BSP_LoadFaces(lump_t *l) oldnumtriangles = out->num_triangles; oldnumtriangles2 = out->num_collisiontriangles; out->num_collisiontriangles = Mod_RemoveDegenerateTriangles(out->num_collisiontriangles, out->data_collisionelement3i, out->data_collisionelement3i, out->data_collisionvertex3f); + + // now optimize the collision mesh by finding triangle bboxes... + Mod_Q3BSP_BuildBBoxes(out->data_collisionelement3i, out->num_collisiontriangles, out->data_collisionvertex3f, &out->data_collisionbbox6f, &out->num_collisionbboxstride, mod_q3bsp_curves_collisions_stride.integer); + Mod_Q3BSP_BuildBBoxes(loadmodel->surfmesh.data_element3i + 3 * out->num_firsttriangle, out->num_triangles, loadmodel->surfmesh.data_vertex3f, &out->data_bbox6f, &out->num_bboxstride, mod_q3bsp_curves_stride.integer); + if (developer.integer >= 100) Con_Printf("Mod_Q3BSP_LoadFaces: %ix%i curve became %i:%i vertices / %i:%i triangles (%i:%i degenerate)\n", patchsize[0], patchsize[1], out->num_vertices, out->num_collisionvertices, oldnumtriangles, oldnumtriangles2, oldnumtriangles - out->num_triangles, oldnumtriangles2 - out->num_collisiontriangles); break; @@ -4889,9 +5119,9 @@ static void Mod_Q3BSP_LoadFaces(lump_t *l) if (cls.state != ca_dedicated && out->lightmaptexture) { // 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) / 128; - int mergeheight = R_TextureHeight(out->lightmaptexture) / 128; + int lightmapindex = LittleLong(in->lightmapindex) >> (loadmodel->brushq3.deluxemapping ? 1 : 0); + 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; @@ -4929,9 +5159,26 @@ static void Mod_Q3BSP_LoadFaces(lump_t *l) //out->lightmapinfo->styles[3] = 255; } + i = oldi; + out = oldout; + for (;i < count;i++, out++) + { + if(out->num_vertices && out->num_triangles) + continue; + if(out->num_vertices == 0) + Con_Printf("Mod_Q3BSP_LoadFaces: surface %d has no vertices, ignoring\n", i); + if(out->num_triangles == 0) + Con_Printf("Mod_Q3BSP_LoadFaces: surface %d has no triangles, ignoring\n", i); + } + // 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) @@ -4946,6 +5193,9 @@ static void Mod_Q3BSP_LoadFaces(lump_t *l) if (loadmodel->brushq3.data_element3i) Mem_Free(loadmodel->brushq3.data_element3i); loadmodel->brushq3.data_element3i = NULL; + + if(patchtess) + Mem_Free(patchtess); } static void Mod_Q3BSP_LoadModels(lump_t *l) @@ -5155,7 +5405,10 @@ static void Mod_Q3BSP_LoadLightGrid(lump_t *l) if (l->filelen) { if (l->filelen < count * (int)sizeof(*in)) - Host_Error("Mod_Q3BSP_LoadLightGrid: invalid lightgrid lump size %i bytes, should be %i bytes (%ix%ix%i)", l->filelen, (int)(count * sizeof(*in)), loadmodel->brushq3.num_lightgrid_dimensions[0], loadmodel->brushq3.num_lightgrid_dimensions[1], loadmodel->brushq3.num_lightgrid_dimensions[2]); + { + Con_Printf("Mod_Q3BSP_LoadLightGrid: invalid lightgrid lump size %i bytes, should be %i bytes (%ix%ix%i)", l->filelen, (int)(count * sizeof(*in)), loadmodel->brushq3.num_lightgrid_isize[0], loadmodel->brushq3.num_lightgrid_isize[1], loadmodel->brushq3.num_lightgrid_isize[2]); + return; // ignore the grid if we cannot understand it + } if (l->filelen != count * (int)sizeof(*in)) Con_Printf("Mod_Q3BSP_LoadLightGrid: Warning: calculated lightgrid size %i bytes does not match lump size %i\n", (int)(count * sizeof(*in)), l->filelen); out = (q3dlightgrid_t *)Mem_Alloc(loadmodel->mempool, count * sizeof(*out)); @@ -5204,14 +5457,14 @@ static void Mod_Q3BSP_LoadPVS(lump_t *l) memcpy(loadmodel->brush.data_pvsclusters, (unsigned char *)(in + 1), totalchains); } -static void Mod_Q3BSP_LightPoint(model_t *model, const vec3_t p, vec3_t ambientcolor, vec3_t diffusecolor, vec3_t diffusenormal) +static void Mod_Q3BSP_LightPoint(dp_model_t *model, const vec3_t p, vec3_t ambientcolor, vec3_t diffusecolor, vec3_t diffusenormal) { int i, j, k, index[3]; float transformed[3], blend1, blend2, blend, 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) { @@ -5269,14 +5522,92 @@ static void Mod_Q3BSP_LightPoint(model_t *model, const vec3_t p, vec3_t ambientc //Con_Printf("result: ambient %f %f %f diffuse %f %f %f diffusenormal %f %f %f\n", ambientcolor[0], ambientcolor[1], ambientcolor[2], diffusecolor[0], diffusecolor[1], diffusecolor[2], diffusenormal[0], diffusenormal[1], diffusenormal[2]); } -static void Mod_Q3BSP_TracePoint_RecursiveBSPNode(trace_t *trace, model_t *model, mnode_t *node, const vec3_t point, int markframe) +static int Mod_Q3BSP_TraceLineOfSight_RecursiveNodeCheck(mnode_t *node, double p1[3], double p2[3]) +{ + double t1, t2; + double midf, mid[3]; + int ret, side; + + // check for empty + while (node->plane) + { + // find the point distances + mplane_t *plane = node->plane; + if (plane->type < 3) + { + t1 = p1[plane->type] - plane->dist; + t2 = p2[plane->type] - plane->dist; + } + else + { + t1 = DotProduct (plane->normal, p1) - plane->dist; + t2 = DotProduct (plane->normal, p2) - plane->dist; + } + + if (t1 < 0) + { + if (t2 < 0) + { + node = node->children[1]; + continue; + } + side = 1; + } + else + { + if (t2 >= 0) + { + node = node->children[0]; + continue; + } + side = 0; + } + + midf = t1 / (t1 - t2); + VectorLerp(p1, midf, p2, mid); + + // recurse both sides, front side first + // return 2 if empty is followed by solid (hit something) + // do not return 2 if both are solid or both empty, + // or if start is solid and end is empty + // as these degenerate cases usually indicate the eye is in solid and + // should see the target point anyway + ret = Mod_Q3BSP_TraceLineOfSight_RecursiveNodeCheck(node->children[side ], p1, mid); + if (ret != 0) + return ret; + ret = Mod_Q3BSP_TraceLineOfSight_RecursiveNodeCheck(node->children[side ^ 1], mid, p2); + if (ret != 1) + return ret; + return 2; + } + return ((mleaf_t *)node)->clusterindex < 0; +} + +static qboolean Mod_Q3BSP_TraceLineOfSight(struct model_s *model, const vec3_t start, const vec3_t end) +{ + if (model->brush.submodel || mod_q3bsp_tracelineofsight_brushes.integer) + { + trace_t trace; + model->TraceLine(model, NULL, NULL, &trace, start, end, SUPERCONTENTS_VISBLOCKERMASK); + return trace.fraction == 1; + } + else + { + double tracestart[3], traceend[3]; + VectorCopy(start, tracestart); + VectorCopy(end, traceend); + return !Mod_Q3BSP_TraceLineOfSight_RecursiveNodeCheck(model->brush.data_nodes, tracestart, traceend); + } +} + +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++) @@ -5291,7 +5622,7 @@ static void Mod_Q3BSP_TracePoint_RecursiveBSPNode(trace_t *trace, model_t *model // can't do point traces on curves (they have no thickness) } -static void Mod_Q3BSP_TraceLine_RecursiveBSPNode(trace_t *trace, model_t *model, mnode_t *node, const vec3_t start, const vec3_t end, vec_t startfrac, vec_t endfrac, const vec3_t linestart, const vec3_t lineend, int markframe, const vec3_t segmentmins, const vec3_t segmentmaxs) +static void Mod_Q3BSP_TraceLine_RecursiveBSPNode(trace_t *trace, dp_model_t *model, mnode_t *node, const vec3_t start, const vec3_t end, vec_t startfrac, vec_t endfrac, const vec3_t linestart, const vec3_t lineend, int markframe, const vec3_t segmentmins, const vec3_t segmentmaxs) { int i, startside, endside; float dist1, dist2, midfrac, mid[3], nodesegmentmins[3], nodesegmentmaxs[3]; @@ -5372,13 +5703,13 @@ static void Mod_Q3BSP_TraceLine_RecursiveBSPNode(trace_t *trace, model_t *model, if (surface->num_collisiontriangles && surface->collisionmarkframe != markframe && BoxesOverlap(nodesegmentmins, nodesegmentmaxs, surface->mins, surface->maxs)) { surface->collisionmarkframe = markframe; - Collision_TraceLineTriangleMeshFloat(trace, linestart, lineend, surface->num_collisiontriangles, surface->data_collisionelement3i, surface->data_collisionvertex3f, surface->texture->supercontents, surface->texture->surfaceflags, surface->texture, segmentmins, segmentmaxs); + Collision_TraceLineTriangleMeshFloat(trace, linestart, lineend, surface->num_collisiontriangles, surface->data_collisionelement3i, surface->data_collisionvertex3f, surface->num_collisionbboxstride, surface->data_collisionbbox6f, surface->texture->supercontents, surface->texture->surfaceflags, surface->texture, segmentmins, segmentmaxs); } } } } -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; @@ -5453,93 +5784,157 @@ static void Mod_Q3BSP_TraceBrush_RecursiveBSPNode(trace_t *trace, model_t *model if (surface->num_collisiontriangles && surface->collisionmarkframe != markframe && BoxesOverlap(nodesegmentmins, nodesegmentmaxs, surface->mins, surface->maxs)) { surface->collisionmarkframe = markframe; - Collision_TraceBrushTriangleMeshFloat(trace, thisbrush_start, thisbrush_end, surface->num_collisiontriangles, surface->data_collisionelement3i, surface->data_collisionvertex3f, surface->texture->supercontents, surface->texture->surfaceflags, surface->texture, segmentmins, segmentmaxs); + Collision_TraceBrushTriangleMeshFloat(trace, thisbrush_start, thisbrush_end, surface->num_collisiontriangles, surface->data_collisionelement3i, surface->data_collisionvertex3f, surface->num_collisionbboxstride, surface->data_collisionbbox6f, surface->texture->supercontents, surface->texture->surfaceflags, surface->texture, segmentmins, segmentmaxs); } } } } -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 int markframe = 0; + +static void Mod_Q3BSP_TracePoint(dp_model_t *model, const frameblend_t *frameblend, const skeleton_t *skeleton, trace_t *trace, const vec3_t start, int hitsupercontentsmask) +{ + int i; + q3mbrush_t *brush; + memset(trace, 0, sizeof(*trace)); + trace->fraction = 1; + trace->realfraction = 1; + trace->hitsupercontentsmask = hitsupercontentsmask; + if (model->brush.submodel) + { + for (i = 0, brush = model->brush.data_brushes + model->firstmodelbrush;i < model->nummodelbrushes;i++, brush++) + if (brush->colbrushf) + Collision_TracePointBrushFloat(trace, start, brush->colbrushf); + } + else + Mod_Q3BSP_TracePoint_RecursiveBSPNode(trace, model, model->brush.data_nodes, start, ++markframe); +} + +static void Mod_Q3BSP_TraceLine(dp_model_t *model, const frameblend_t *frameblend, const skeleton_t *skeleton, trace_t *trace, const vec3_t start, const vec3_t end, int hitsupercontentsmask) { int i; float segmentmins[3], segmentmaxs[3]; - static int markframe = 0; msurface_t *surface; q3mbrush_t *brush; + + if (VectorCompare(start, end)) + { + Mod_Q3BSP_TracePoint(model, frameblend, skeleton, trace, start, hitsupercontentsmask); + return; + } + memset(trace, 0, sizeof(*trace)); trace->fraction = 1; trace->realfraction = 1; trace->hitsupercontentsmask = hitsupercontentsmask; - if (mod_q3bsp_optimizedtraceline.integer && VectorLength2(boxmins) + VectorLength2(boxmaxs) == 0) + segmentmins[0] = min(start[0], end[0]) - 1; + segmentmins[1] = min(start[1], end[1]) - 1; + segmentmins[2] = min(start[2], end[2]) - 1; + segmentmaxs[0] = max(start[0], end[0]) + 1; + segmentmaxs[1] = max(start[1], end[1]) + 1; + segmentmaxs[2] = max(start[2], end[2]) + 1; + if (model->brush.submodel) + { + for (i = 0, brush = model->brush.data_brushes + model->firstmodelbrush;i < model->nummodelbrushes;i++, brush++) + if (brush->colbrushf) + Collision_TraceLineBrushFloat(trace, start, end, brush->colbrushf, brush->colbrushf); + if (mod_q3bsp_curves_collisions.integer) + for (i = 0, surface = model->data_surfaces + model->firstmodelsurface;i < model->nummodelsurfaces;i++, surface++) + if (surface->num_collisiontriangles) + Collision_TraceLineTriangleMeshFloat(trace, start, end, surface->num_collisiontriangles, surface->data_collisionelement3i, surface->data_collisionvertex3f, surface->num_collisionbboxstride, surface->data_collisionbbox6f, surface->texture->supercontents, surface->texture->surfaceflags, surface->texture, segmentmins, segmentmaxs); + } + else + Mod_Q3BSP_TraceLine_RecursiveBSPNode(trace, model, model->brush.data_nodes, start, end, 0, 1, start, end, ++markframe, segmentmins, segmentmaxs); +} + +static void Mod_Q3BSP_TraceBox(dp_model_t *model, const frameblend_t *frameblend, const skeleton_t *skeleton, 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]; + msurface_t *surface; + q3mbrush_t *brush; + colboxbrushf_t thisbrush_start, thisbrush_end; + vec3_t boxstartmins, boxstartmaxs, boxendmins, boxendmaxs; + + if (mod_q3bsp_optimizedtraceline.integer && VectorCompare(boxmins, boxmaxs)) { + vec3_t shiftstart, shiftend; + VectorAdd(start, boxmins, shiftstart); + VectorAdd(end, boxmins, shiftend); if (VectorCompare(start, end)) - { - // point trace - if (model->brush.submodel) - { - for (i = 0, brush = model->brush.data_brushes + model->firstmodelbrush;i < model->nummodelbrushes;i++, brush++) - if (brush->colbrushf) - Collision_TracePointBrushFloat(trace, start, brush->colbrushf); - } - else - Mod_Q3BSP_TracePoint_RecursiveBSPNode(trace, model, model->brush.data_nodes, start, ++markframe); - } + Mod_Q3BSP_TracePoint(model, frameblend, skeleton, trace, shiftstart, hitsupercontentsmask); else { - // line trace - segmentmins[0] = min(start[0], end[0]) - 1; - segmentmins[1] = min(start[1], end[1]) - 1; - segmentmins[2] = min(start[2], end[2]) - 1; - segmentmaxs[0] = max(start[0], end[0]) + 1; - segmentmaxs[1] = max(start[1], end[1]) + 1; - segmentmaxs[2] = max(start[2], end[2]) + 1; - if (model->brush.submodel) - { - for (i = 0, brush = model->brush.data_brushes + model->firstmodelbrush;i < model->nummodelbrushes;i++, brush++) - if (brush->colbrushf) - Collision_TraceLineBrushFloat(trace, start, end, brush->colbrushf, brush->colbrushf); - if (mod_q3bsp_curves_collisions.integer) - for (i = 0, surface = model->data_surfaces + model->firstmodelsurface;i < model->nummodelsurfaces;i++, surface++) - if (surface->num_collisiontriangles) - Collision_TraceLineTriangleMeshFloat(trace, start, end, surface->num_collisiontriangles, surface->data_collisionelement3i, surface->data_collisionvertex3f, surface->texture->supercontents, surface->texture->surfaceflags, surface->texture, segmentmins, segmentmaxs); - } - else - Mod_Q3BSP_TraceLine_RecursiveBSPNode(trace, model, model->brush.data_nodes, start, end, 0, 1, start, end, ++markframe, segmentmins, segmentmaxs); + Mod_Q3BSP_TraceLine(model, frameblend, skeleton, trace, shiftstart, shiftend, hitsupercontentsmask); + VectorSubtract(trace->endpos, boxmins, trace->endpos); } + return; + } + + // box trace, performed as brush trace + memset(trace, 0, sizeof(*trace)); + trace->fraction = 1; + trace->realfraction = 1; + trace->hitsupercontentsmask = hitsupercontentsmask; + segmentmins[0] = min(start[0], end[0]) + boxmins[0] - 1; + segmentmins[1] = min(start[1], end[1]) + boxmins[1] - 1; + segmentmins[2] = min(start[2], end[2]) + boxmins[2] - 1; + segmentmaxs[0] = max(start[0], end[0]) + boxmaxs[0] + 1; + segmentmaxs[1] = max(start[1], end[1]) + boxmaxs[1] + 1; + segmentmaxs[2] = max(start[2], end[2]) + boxmaxs[2] + 1; + VectorAdd(start, boxmins, boxstartmins); + VectorAdd(start, boxmaxs, boxstartmaxs); + VectorAdd(end, boxmins, boxendmins); + VectorAdd(end, boxmaxs, boxendmaxs); + Collision_BrushForBox(&thisbrush_start, boxstartmins, boxstartmaxs, 0, 0, NULL); + Collision_BrushForBox(&thisbrush_end, boxendmins, boxendmaxs, 0, 0, NULL); + if (model->brush.submodel) + { + for (i = 0, brush = model->brush.data_brushes + model->firstmodelbrush;i < model->nummodelbrushes;i++, brush++) + if (brush->colbrushf) + Collision_TraceBrushBrushFloat(trace, &thisbrush_start.brush, &thisbrush_end.brush, brush->colbrushf, brush->colbrushf); + if (mod_q3bsp_curves_collisions.integer) + for (i = 0, surface = model->data_surfaces + model->firstmodelsurface;i < model->nummodelsurfaces;i++, surface++) + if (surface->num_collisiontriangles) + Collision_TraceBrushTriangleMeshFloat(trace, &thisbrush_start.brush, &thisbrush_end.brush, surface->num_collisiontriangles, surface->data_collisionelement3i, surface->data_collisionvertex3f, surface->num_collisionbboxstride, surface->data_collisionbbox6f, surface->texture->supercontents, surface->texture->surfaceflags, surface->texture, segmentmins, segmentmaxs); + } + else + Mod_Q3BSP_TraceBrush_RecursiveBSPNode(trace, model, model->brush.data_nodes, &thisbrush_start.brush, &thisbrush_end.brush, ++markframe, segmentmins, segmentmaxs); +} + +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 { - // box trace, performed as brush trace - colbrushf_t *thisbrush_start, *thisbrush_end; - vec3_t boxstartmins, boxstartmaxs, boxendmins, boxendmaxs; - segmentmins[0] = min(start[0], end[0]) + boxmins[0] - 1; - segmentmins[1] = min(start[1], end[1]) + boxmins[1] - 1; - segmentmins[2] = min(start[2], end[2]) + boxmins[2] - 1; - segmentmaxs[0] = max(start[0], end[0]) + boxmaxs[0] + 1; - segmentmaxs[1] = max(start[1], end[1]) + boxmaxs[1] + 1; - segmentmaxs[2] = max(start[2], end[2]) + boxmaxs[2] + 1; - VectorAdd(start, boxmins, boxstartmins); - VectorAdd(start, boxmaxs, boxstartmaxs); - VectorAdd(end, boxmins, boxendmins); - VectorAdd(end, boxmaxs, boxendmaxs); - thisbrush_start = Collision_BrushForBox(&identitymatrix, boxstartmins, boxstartmaxs, 0, 0, NULL); - thisbrush_end = Collision_BrushForBox(&identitymatrix, boxendmins, boxendmaxs, 0, 0, NULL); - if (model->brush.submodel) - { - for (i = 0, brush = model->brush.data_brushes + model->firstmodelbrush;i < model->nummodelbrushes;i++, brush++) - if (brush->colbrushf) - Collision_TraceBrushBrushFloat(trace, thisbrush_start, thisbrush_end, brush->colbrushf, brush->colbrushf); - if (mod_q3bsp_curves_collisions.integer) - for (i = 0, surface = model->data_surfaces + model->firstmodelsurface;i < model->nummodelsurfaces;i++, surface++) - if (surface->num_collisiontriangles) - Collision_TraceBrushTriangleMeshFloat(trace, thisbrush_start, thisbrush_end, surface->num_collisiontriangles, surface->data_collisionelement3i, surface->data_collisionvertex3f, surface->texture->supercontents, surface->texture->surfaceflags, surface->texture, segmentmins, segmentmaxs); + 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; } - else - Mod_Q3BSP_TraceBrush_RecursiveBSPNode(trace, model, model->brush.data_nodes, thisbrush_start, thisbrush_end, ++markframe, segmentmins, segmentmaxs); } + return supercontents; } -static int Mod_Q3BSP_SuperContentsFromNativeContents(model_t *model, int nativecontents) +static int Mod_Q3BSP_SuperContentsFromNativeContents(dp_model_t *model, int nativecontents) { int supercontents = 0; if (nativecontents & CONTENTSQ3_SOLID) @@ -5562,10 +5957,14 @@ static int Mod_Q3BSP_SuperContentsFromNativeContents(model_t *model, int nativec supercontents |= SUPERCONTENTS_MONSTERCLIP; if (nativecontents & CONTENTSQ3_DONOTENTER) supercontents |= SUPERCONTENTS_DONOTENTER; + if (nativecontents & CONTENTSQ3_BOTCLIP) + supercontents |= SUPERCONTENTS_BOTCLIP; + if (!(nativecontents & CONTENTSQ3_TRANSLUCENT)) + supercontents |= SUPERCONTENTS_OPAQUE; 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) @@ -5588,6 +5987,10 @@ static int Mod_Q3BSP_NativeContentsFromSuperContents(model_t *model, int superco nativecontents |= CONTENTSQ3_MONSTERCLIP; if (supercontents & SUPERCONTENTS_DONOTENTER) nativecontents |= CONTENTSQ3_DONOTENTER; + if (supercontents & SUPERCONTENTS_BOTCLIP) + nativecontents |= CONTENTSQ3_BOTCLIP; + if (!(supercontents & SUPERCONTENTS_OPAQUE)) + nativecontents |= CONTENTSQ3_TRANSLUCENT; return nativecontents; } @@ -5604,9 +6007,9 @@ void Mod_Q3BSP_RecursiveFindNumLeafs(mnode_t *node) loadmodel->brush.num_leafs = numleafs; } -void Mod_Q3BSP_Load(model_t *mod, void *buffer, void *bufferend) +void Mod_Q3BSP_Load(dp_model_t *mod, void *buffer, void *bufferend) { - int i, j, numshadowmeshtriangles; + int i, j, numshadowmeshtriangles, lumps; q3dheader_t *header; float corner[3], yawradius, modelradius; msurface_t *surface; @@ -5618,21 +6021,19 @@ void Mod_Q3BSP_Load(model_t *mod, void *buffer, void *bufferend) mod->numskins = 1; header = (q3dheader_t *)buffer; + if((char *) bufferend < (char *) buffer + sizeof(q3dheader_t)) + Host_Error("Mod_Q3BSP_Load: %s is smaller than its header", mod->name); 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->brush.TraceLineOfSight = Mod_Q1BSP_TraceLineOfSight; + mod->TraceLine = Mod_Q3BSP_TraceLine; + mod->TracePoint = Mod_Q3BSP_TracePoint; + mod->PointSuperContents = Mod_Q3BSP_PointSuperContents; + mod->brush.TraceLineOfSight = Mod_Q3BSP_TraceLineOfSight; mod->brush.SuperContentsFromNativeContents = Mod_Q3BSP_SuperContentsFromNativeContents; mod->brush.NativeContentsFromSuperContents = Mod_Q3BSP_NativeContentsFromSuperContents; mod->brush.GetPVS = Mod_Q1BSP_GetPVS; @@ -5643,30 +6044,51 @@ void Mod_Q3BSP_Load(model_t *mod, void *buffer, void *bufferend) mod->brush.FindBoxClusters = Mod_Q1BSP_FindBoxClusters; mod->brush.LightPoint = Mod_Q3BSP_LightPoint; mod->brush.FindNonSolidLocation = Mod_Q1BSP_FindNonSolidLocation; + mod->brush.AmbientSoundLevelsForPoint = NULL; + mod->brush.RoundUpToHullSize = NULL; mod->brush.PointInLeaf = Mod_Q1BSP_PointInLeaf; mod->Draw = R_Q1BSP_Draw; mod->DrawDepth = R_Q1BSP_DrawDepth; mod->DrawDebug = R_Q1BSP_DrawDebug; + mod->DrawPrepass = R_Q1BSP_DrawPrepass; mod->GetLightInfo = R_Q1BSP_GetLightInfo; + mod->CompileShadowMap = R_Q1BSP_CompileShadowMap; + mod->DrawShadowMap = R_Q1BSP_DrawShadowMap; 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); + j = (header->lumps[i].fileofs = LittleLong(header->lumps[i].fileofs)); + if((char *) bufferend < (char *) buffer + j) + Host_Error("Mod_Q3BSP_Load: %s has a lump that starts outside the file!", mod->name); + j += (header->lumps[i].filelen = LittleLong(header->lumps[i].filelen)); + if((char *) bufferend < (char *) buffer + j) + Host_Error("Mod_Q3BSP_Load: %s has a lump that ends outside the file!", mod->name); + } + /* + * NO, do NOT clear them! + * they contain actual data referenced by other stuff. + * Instead, before using the advertisements lump, check header->versio + * again! + * Sorry, but otherwise it breaks memory of the first lump. + 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; @@ -5674,12 +6096,18 @@ void Mod_Q3BSP_Load(model_t *mod, void *buffer, void *bufferend) if (i == Q3LUMP_PVS || i == Q3LUMP_LEAFS || i == Q3LUMP_NODES) continue; mod->brush.qw_md4sum2 ^= Com_BlockChecksum(mod_base + header->lumps[i].fileofs, header->lumps[i].filelen); + + // all this checksumming can take a while, so let's send keepalives here too + CL_KeepaliveMessage(false); } 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]); @@ -5703,28 +6131,26 @@ void Mod_Q3BSP_Load(model_t *mod, void *buffer, void *bufferend) // make a single combined shadow mesh to allow optimized shadow volume creation numshadowmeshtriangles = 0; - for (j = 0, surface = loadmodel->data_surfaces;j < loadmodel->num_surfaces;j++, surface++) + if (cls.state != ca_dedicated) { - surface->num_firstshadowmeshtriangle = numshadowmeshtriangles; - numshadowmeshtriangles += surface->num_triangles; + for (j = 0, surface = loadmodel->data_surfaces;j < loadmodel->num_surfaces;j++, surface++) + { + surface->num_firstshadowmeshtriangle = numshadowmeshtriangles; + numshadowmeshtriangles += surface->num_triangles; + } + loadmodel->brush.shadowmesh = Mod_ShadowMesh_Begin(loadmodel->mempool, numshadowmeshtriangles * 3, numshadowmeshtriangles, NULL, NULL, NULL, false, false, true); + for (j = 0, surface = loadmodel->data_surfaces;j < loadmodel->num_surfaces;j++, surface++) + if (surface->num_triangles > 0) + Mod_ShadowMesh_AddMesh(loadmodel->mempool, loadmodel->brush.shadowmesh, NULL, NULL, NULL, loadmodel->surfmesh.data_vertex3f, NULL, NULL, NULL, NULL, surface->num_triangles, (loadmodel->surfmesh.data_element3i + 3 * surface->num_firsttriangle)); + loadmodel->brush.shadowmesh = Mod_ShadowMesh_Finish(loadmodel->mempool, loadmodel->brush.shadowmesh, false, true, false); + Mod_BuildTriangleNeighbors(loadmodel->brush.shadowmesh->neighbor3i, loadmodel->brush.shadowmesh->element3i, loadmodel->brush.shadowmesh->numtriangles); } - loadmodel->brush.shadowmesh = Mod_ShadowMesh_Begin(loadmodel->mempool, numshadowmeshtriangles * 3, numshadowmeshtriangles, NULL, NULL, NULL, false, false, true); - for (j = 0, surface = loadmodel->data_surfaces;j < loadmodel->num_surfaces;j++, surface++) - if (surface->num_triangles > 0) - Mod_ShadowMesh_AddMesh(loadmodel->mempool, loadmodel->brush.shadowmesh, NULL, NULL, NULL, loadmodel->surfmesh.data_vertex3f, NULL, NULL, NULL, NULL, surface->num_triangles, (loadmodel->surfmesh.data_element3i + 3 * surface->num_firsttriangle)); - loadmodel->brush.shadowmesh = Mod_ShadowMesh_Finish(loadmodel->mempool, loadmodel->brush.shadowmesh, false, true, false); - Mod_BuildTriangleNeighbors(loadmodel->brush.shadowmesh->neighbor3i, loadmodel->brush.shadowmesh->element3i, loadmodel->brush.shadowmesh->numtriangles); loadmodel->brush.num_leafs = 0; Mod_Q3BSP_RecursiveFindNumLeafs(loadmodel->brush.data_nodes); - if (loadmodel->isworldmodel) - { - // clear out any stale submodels or worldmodels lying around - // if we did this clear before now, an error might abort loading and - // leave things in a bad state - Mod_RemoveStaleWorldModels(loadmodel); - } + if (loadmodel->brush.numsubmodels) + loadmodel->brush.submodels = (dp_model_t **)Mem_Alloc(loadmodel->mempool, loadmodel->brush.numsubmodels * sizeof(dp_model_t *)); mod = loadmodel; for (i = 0;i < loadmodel->brush.numsubmodels;i++) @@ -5732,20 +6158,17 @@ void Mod_Q3BSP_Load(model_t *mod, void *buffer, void *bufferend) if (i > 0) { char name[10]; - // LordHavoc: only register submodels if it is the world - // (prevents external bsp models from replacing world submodels with - // their own) - if (!loadmodel->isworldmodel) - continue; // duplicate the basic information - sprintf(name, "*%i", i); - mod = Mod_FindName(name); + dpsnprintf(name, sizeof(name), "*%i", i); + mod = Mod_FindName(name, loadmodel->name); + // copy the base model to this one *mod = *loadmodel; + // rename the clone back to its proper name strlcpy(mod->name, name, sizeof(mod->name)); + mod->brush.parentmodel = loadmodel; // textures and memory belong to the main model mod->texturepool = NULL; mod->mempool = NULL; - mod->brush.TraceLineOfSight = NULL; mod->brush.GetPVS = NULL; mod->brush.FatPVS = NULL; mod->brush.BoxTouchingPVS = NULL; @@ -5753,21 +6176,46 @@ void Mod_Q3BSP_Load(model_t *mod, void *buffer, void *bufferend) mod->brush.BoxTouchingVisibleLeafs = NULL; mod->brush.FindBoxClusters = NULL; mod->brush.LightPoint = NULL; - mod->brush.FindNonSolidLocation = Mod_Q1BSP_FindNonSolidLocation; + mod->brush.AmbientSoundLevelsForPoint = NULL; } mod->brush.submodel = i; + if (loadmodel->brush.submodels) + loadmodel->brush.submodels[i] = mod; // make the model surface list (used by shadowing/lighting) mod->firstmodelsurface = mod->brushq3.data_models[i].firstface; mod->nummodelsurfaces = mod->brushq3.data_models[i].numfaces; mod->firstmodelbrush = mod->brushq3.data_models[i].firstbrush; mod->nummodelbrushes = mod->brushq3.data_models[i].numbrushes; - mod->surfacelist = (int *)Mem_Alloc(loadmodel->mempool, mod->nummodelsurfaces * sizeof(*mod->surfacelist)); - for (j = 0;j < mod->nummodelsurfaces;j++) - mod->surfacelist[j] = mod->firstmodelsurface + j; + mod->sortedmodelsurfaces = (int *)Mem_Alloc(loadmodel->mempool, mod->nummodelsurfaces * sizeof(*mod->sortedmodelsurfaces)); + Mod_MakeSortedSurfaces(mod); 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])); @@ -5782,28 +6230,28 @@ void Mod_Q3BSP_Load(model_t *mod, void *buffer, void *bufferend) mod->radius = modelradius; mod->radius2 = modelradius * modelradius; + // this gets altered below if sky or water is used + mod->DrawSky = NULL; + mod->DrawAddWaterPlanes = NULL; + for (j = 0;j < mod->nummodelsurfaces;j++) 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); @@ -5811,12 +6259,933 @@ void Mod_IBSP_Load(model_t *mod, void *buffer, void *bufferend) Host_Error("Mod_IBSP_Load: unknown/unsupported version %i", i); } -void Mod_MAP_Load(model_t *mod, void *buffer, void *bufferend) +void Mod_MAP_Load(dp_model_t *mod, void *buffer, void *bufferend) { Host_Error("Mod_MAP_Load: not yet implemented"); } -qboolean Mod_CanSeeBox_Trace(int numsamples, float t, model_t *model, vec3_t eye, vec3_t minsX, vec3_t maxsX) +#ifdef OBJWORKS +typedef struct objvertex_s +{ + float v[3]; + float vt[2]; + float vn[3]; +} +objvertex_t; + +typedef struct objtriangle_s +{ + objvertex_t vertex[3]; + int textureindex; + // these fields are used only in conversion to surfaces + int axis; + int surfaceindex; + int surfacevertexindex[3]; + float edgeplane[3][4]; +} +objtriangle_t; + +typedef objnode_s +{ + struct objnode_s *children[2]; + struct objnode_s *parent; + objtriangle_t *triangles; + float normal[3]; + float dist; + float mins[3]; + float maxs[3]; + int numtriangles; +} +objnode_t; + +objnode_t *Mod_OBJ_BSPNodeForTriangles(objnode_t *parent, objtriangle_t *triangles, int numtriangles, const float *mins, const float *maxs, mem_expandablearray_t *nodesarray, int maxclippedtriangles, objtriangle_t *clippedfronttriangles, objtriangle_t *clippedbacktriangles) +{ + int i, j; + float normal[3]; + float dist; + int score; + float bestnormal[3]; + float bestdist; + int bestscore; + float mins[3]; + float maxs[3]; + int numfronttriangles; + int numbacktriangles; + int count_front; + int count_back; + int count_both; + int count_on; + float outfrontpoints[5][3]; + float outbackpoints[5][3]; + int neededfrontpoints; + int neededbackpoints; + int countonpoints; + objnode_t *node; + + node = (objnode_t *)Mem_ExpandableArray_AllocRecord(array); + node->parent = parent; + if (numtriangles) + { + VectorCopy(triangles[0].vertex[0].v, mins); + VectorCopy(triangles[0].vertex[0].v, maxs); + } + else if (parent && parent->children[0] == node) + { + VectorCopy(parent->mins, mins); + Vectorcopy(parent->maxs, maxs); + } + else if (parent && parent->children[1] == node) + { + VectorCopy(parent->mins, mins); + Vectorcopy(parent->maxs, maxs); + } + else + { + VectorClear(mins); + VectorClear(maxs); + } + for (i = 0;i < numtriangles;i++) + { + for (j = 0;j < 3;j++) + { + mins[0] = min(mins[0], triangles[i].vertex[j].v[0]); + mins[1] = min(mins[1], triangles[i].vertex[j].v[1]); + mins[2] = min(mins[2], triangles[i].vertex[j].v[2]); + maxs[0] = max(maxs[0], triangles[i].vertex[j].v[0]); + maxs[1] = max(maxs[1], triangles[i].vertex[j].v[1]); + maxs[2] = max(maxs[2], triangles[i].vertex[j].v[2]); + } + } + VectorCopy(mins, node->mins); + VectorCopy(maxs, node->maxs); + if (numtriangles <= mod_obj_leaftriangles.integer) + { + // create a leaf + loadmodel->brush.num_leafs++; + node->triangles = triangles; + node->numtriangles = numtriangles; + return node; + } + + // create a node + loadmodel->brush.num_nodes++; + // pick a splitting plane from the various choices available to us... + // early splits simply halve the interval + bestscore = 0; + VectorClear(bestnormal); + bestdist = 0; + if (numtriangles <= mod_obj_splitterlimit.integer) + limit = numtriangles; + else + limit = 0; + for (i = -3;i < limit;i++) + { + if (i < 0) + { + // first we try 3 axial splits (kdtree-like) + j = i + 3; + VectorClear(normal); + normal[j] = 1; + dist = (mins[j] + maxs[j]) * 0.5f; + } + else + { + // then we try each triangle plane + TriangleNormal(triangles[i].vertex[0].v, triangles[i].vertex[1].v, triangles[i].vertex[2].v, normal); + VectorNormalize(normal); + dist = DotProduct(normal, triangles[i].vertex[0].v); + // use positive axial values whenever possible + if (normal[0] == -1) + normal[0] = 1; + if (normal[1] == -1) + normal[1] = 1; + if (normal[2] == -1) + normal[2] = 1; + // skip planes that match the current best + if (VectorCompare(normal, bestnormal) && dist == bestdist) + continue; + } + count_on = 0; + count_front = 0; + count_back = 0; + count_both = 0; + for (j = 0;j < numtriangles;j++) + { + dists[0] = DotProduct(normal, triangles[j].vertex[0].v) - dist; + dists[1] = DotProduct(normal, triangles[j].vertex[1].v) - dist; + dists[2] = DotProduct(normal, triangles[j].vertex[2].v) - dist; + if (dists[0] < -DIST_EPSILON || dists[1] < -DIST_EPSILON || dists[2] < -DIST_EPSILON) + { + if (dists[0] > DIST_EPSILON || dists[1] > DIST_EPSILON || dists[2] > DIST_EPSILON) + count_both++; + else + count_back++; + } + else if (dists[0] > DIST_EPSILON || dists[1] > DIST_EPSILON || dists[2] > DIST_EPSILON) + count_front++; + else + count_on++; + } + // score is supposed to: + // prefer axial splits + // prefer evenly dividing the input triangles + // prefer triangles on the plane + // avoid triangles crossing the plane + score = count_on*count_on - count_both*count_both + min(count_front, count_back)*(count_front+count_back); + if (normal[0] == 1 || normal[1] == 1 || normal[2] == 1) + score *= 2; + if (i == -3 || bestscore < score) + { + VectorCopy(normal, bestnormal); + bestdist = dist; + bestscore = score; + } + } + + // now we have chosen an optimal split plane... + + // divide triangles by the splitting plane + numfronttriangles = 0; + numbacktriangles = 0; + for (i = 0;i < numtriangles;i++) + { + neededfrontpoints = 0; + neededbackpoints = 0; + countonpoints = 0; + PolygonF_Divide(3, triangles[i].vertex[0].v, bestnormal[0], bestnormal[1], bestnormal[2], bestdist, DIST_EPSILON, 5, outfrontpoints[0], &neededfrontpoints, 5, outbackpoints[0], &neededbackpoints, &countonpoints); + if (countonpoints > 1) + { + // triangle lies on plane, assign it to one child only + TriangleNormal(triangles[i].vertex[0].v, triangles[i].vertex[1].v, triangles[i].vertex[2].v, normal); + if (DotProduct(bestnormal, normal) >= 0) + { + // assign to front side child + obj_fronttriangles[numfronttriangles++] = triangles[i]; + } + else + { + // assign to back side child + obj_backtriangles[numbacktriangles++] = triangles[i]; + } + } + else + { + // convert clipped polygons to triangles + for (j = 0;j < neededfrontpoints-2;j++) + { + obj_fronttriangles[numfronttriangles] = triangles[i]; + VectorCopy(outfrontpoints[0], obj_fronttriangles[numfronttriangles].vertex[0].v); + VectorCopy(outfrontpoints[j+1], obj_fronttriangles[numfronttriangles].vertex[1].v); + VectorCopy(outfrontpoints[j+2], obj_fronttriangles[numfronttriangles].vertex[2].v); + numfronttriangles++; + } + for (j = 0;j < neededbackpoints-2;j++) + { + obj_backtriangles[numbacktriangles] = triangles[i]; + VectorCopy(outbackpoints[0], obj_backtriangles[numbacktriangles].vertex[0].v); + VectorCopy(outbackpoints[j+1], obj_backtriangles[numbacktriangles].vertex[1].v); + VectorCopy(outbackpoints[j+2], obj_backtriangles[numbacktriangles].vertex[2].v); + numbacktriangles++; + } + } + } + + // now copy the triangles out of the big buffer + if (numfronttriangles) + { + fronttriangles = Mem_Alloc(loadmodel->mempool, fronttriangles * sizeof(*fronttriangles)); + memcpy(fronttriangles, obj_fronttriangles, numfronttriangles * sizeof(*fronttriangles)); + } + else + fronttriangles = NULL; + if (numbacktriangles) + { + backtriangles = Mem_Alloc(loadmodel->mempool, backtriangles * sizeof(*backtriangles)); + memcpy(backtriangles, obj_backtriangles, numbacktriangles * sizeof(*backtriangles)); + } + else + backtriangles = NULL; + + // free the original triangles we were given + if (triangles) + Mem_Free(triangles); + triangles = NULL; + numtriangles = 0; + + // now create the children... + node->children[0] = Mod_OBJ_BSPNodeForTriangles(node, fronttriangles, numfronttriangles, frontmins, frontmaxs, nodesarray, maxclippedtriangles, clippedfronttriangles, clippedbacktriangles); + node->children[1] = Mod_OBJ_BSPNodeForTriangles(node, backtriangles, numbacktriangles, backmins, backmaxs, nodesarray, maxclippedtriangles, clippedfronttriangles, clippedbacktriangles); + return node; +} + +void Mod_OBJ_SnapVertex(float *v) +{ + int i; + float a = mod_obj_vertexprecision.value; + float b = 1.0f / a; + v[0] -= floor(v[0] * a + 0.5f) * b; + v[1] -= floor(v[1] * a + 0.5f) * b; + v[2] -= floor(v[2] * a + 0.5f) * b; +} + +void Mod_OBJ_ConvertBSPNode(objnode_t *objnode, mnode_t *mnodeparent) +{ + if (objnode->children[0]) + { + // convert to mnode_t + mnode_t *mnode = loadmodel->brush.data_nodes + loadmodel->brush.num_nodes++; + mnode->parent = mnodeparent; + mnode->plane = loadmodel->brush.data_planes + loadmodel->brush.num_planes++; + VectorCopy(objnode->normal, mnode->plane->normal); + mnode->plane->dist = objnode->dist; + PlaneClassify(mnode->plane); + VectorCopy(objnode->mins, mnode->mins); + VectorCopy(objnode->maxs, mnode->maxs); + // push combinedsupercontents up to the parent + if (mnodeparent) + mnodeparent->combinedsupercontents |= mnode->combinedsupercontents; + mnode->children[0] = Mod_OBJ_ConvertBSPNode(objnode->children[0], mnode); + mnode->children[1] = Mod_OBJ_ConvertBSPNode(objnode->children[1], mnode); + } + else + { + // convert to mleaf_t + mleaf_t *mleaf = loadmodel->brush.data_leafs + loadmodel->brush.num_leafs++; + mleaf->parent = mnodeparent; + VectorCopy(objnode->mins, mleaf->mins); + VectorCopy(objnode->maxs, mleaf->maxs); + mleaf->clusterindex = loadmodel->brush.num_leafs - 1; + if (objnode->numtriangles) + { + objtriangle_t *triangles = objnode->triangles; + int numtriangles = objnode->numtriangles; + texture_t *texture; + float edge[3][3]; + float normal[3]; + objvertex_t vertex[3]; + numsurfaces = 0; + maxsurfaces = numtriangles; + surfaces = NULL; + // calculate some more data on each triangle for surface gathering + for (i = 0;i < numtriangles;i++) + { + triangle = triangles + i; + texture = loadmodel->data_textures + triangle->textureindex; + Mod_OBJ_SnapVertex(triangle->vertex[0].v); + Mod_OBJ_SnapVertex(triangle->vertex[1].v); + Mod_OBJ_SnapVertex(triangle->vertex[2].v); + TriangleNormal(triangle->vertex[0].v, triangle->vertex[1].v, triangle->vertex[2].v, normal); + axis = 0; + if (fabs(normal[axis]) < fabs(normal[1])) + axis = 1; + if (fabs(normal[axis]) < fabs(normal[2])) + axis = 2; + VectorClear(normal); + normal[axis] = 1; + triangle->axis = axis; + VectorSubtract(triangle->vertex[1].v, triangle->vertex[0].v, edge[0]); + VectorSubtract(triangle->vertex[2].v, triangle->vertex[1].v, edge[1]); + VectorSubtract(triangle->vertex[0].v, triangle->vertex[2].v, edge[2]); + CrossProduct(edge[0], normal, triangle->edgeplane[0]); + CrossProduct(edge[1], normal, triangle->edgeplane[1]); + CrossProduct(edge[2], normal, triangle->edgeplane[2]); + VectorNormalize(triangle->edgeplane[0]); + VectorNormalize(triangle->edgeplane[1]); + VectorNormalize(triangle->edgeplane[2]); + triangle->edgeplane[0][3] = DotProduct(triangle->edgeplane[0], triangle->vertex[0].v); + triangle->edgeplane[1][3] = DotProduct(triangle->edgeplane[1], triangle->vertex[1].v); + triangle->edgeplane[2][3] = DotProduct(triangle->edgeplane[2], triangle->vertex[2].v); + triangle->surfaceindex = 0; + // add to the combined supercontents while we're here... + mleaf->combinedsupercontents |= texture->supercontents; + } + surfaceindex = 1; + for (i = 0;i < numtriangles;i++) + { + // skip already-assigned triangles + if (triangles[i].surfaceindex) + continue; + texture = loadmodel->data_textures + triangles[i].textureindex; + // assign a new surface to this triangle + triangles[i].surfaceindex = surfaceindex++; + axis = triangles[i].axis; + numvertices = 3; + // find the triangle's neighbors, this can take multiple passes + retry = true; + while (retry) + { + retry = false; + for (j = i+1;j < numtriangles;j++) + { + if (triangles[j].surfaceindex || triangles[j].axis != axis || triangles[j].texture != texture) + continue; + triangle = triangles + j; + for (k = i;k < j;k++) + { + if (triangles[k].surfaceindex != surfaceindex) + continue; + if (VectorCompare(triangles[k].vertex[0].v, triangles[j].vertex[0].v) + || VectorCompare(triangles[k].vertex[0].v, triangles[j].vertex[1].v) + || VectorCompare(triangles[k].vertex[0].v, triangles[j].vertex[2].v) + || VectorCompare(triangles[k].vertex[1].v, triangles[j].vertex[0].v) + || VectorCompare(triangles[k].vertex[1].v, triangles[j].vertex[1].v) + || VectorCompare(triangles[k].vertex[1].v, triangles[j].vertex[2].v) + || VectorCompare(triangles[k].vertex[2].v, triangles[j].vertex[0].v) + || VectorCompare(triangles[k].vertex[2].v, triangles[j].vertex[1].v) + || VectorCompare(triangles[k].vertex[2].v, triangles[j].vertex[2].v)) + { + // shares a vertex position + --- FIXME --- + } + } + for (k = 0;k < numvertices;k++) + if (!VectorCompare(vertex[k].v, triangles[j].vertex[0].v) || !VectorCompare(vertex[k].v, triangles[j].vertex[1].v) || !VectorCompare(vertex[k].v, triangles[j].vertex[2].v)) + break; + if (k == numvertices) + break; // not a neighbor + // this triangle is a neighbor and has the same axis and texture + // check now if it overlaps in lightmap projection space + triangles[j].surfaceindex; + if (triangles[j]. + } + } + //triangles[i].surfaceindex = surfaceindex++; + for (surfaceindex = 0;surfaceindex < numsurfaces;surfaceindex++) + { + if (surfaces[surfaceindex].texture != texture) + continue; + // check if any triangles already in this surface overlap in lightmap projection space + + { + } + break; + } + } + // let the collision code simply use the surfaces + mleaf->containscollisionsurfaces = mleaf->combinedsupercontents != 0; + mleaf->numleafsurfaces = ?; + mleaf->firstleafsurface = ?; + } + // push combinedsupercontents up to the parent + if (mnodeparent) + mnodeparent->combinedsupercontents |= mleaf->combinedsupercontents; + } +} +#endif + +void Mod_OBJ_Load(dp_model_t *mod, void *buffer, void *bufferend) +{ +#ifdef OBJWORKS + const char *textbase = (char *)buffer, *text = textbase; + char *s; + char *argv[512]; + char line[1024]; + char materialname[MAX_QPATH]; + int j, index1, index2, index3, first, prev, index; + int argc; + int linelen; + int numtriangles = 0; + int maxtriangles = 131072; + objtriangle_t *triangles = Mem_Alloc(tempmempool, maxtriangles * sizeof(*triangles)); + int linenumber = 0; + int maxtextures = 256, numtextures = 0, textureindex = 0; + int maxv = 1024, numv = 0; + int maxvt = 1024, numvt = 0; + int maxvn = 1024, numvn = 0; + char **texturenames; + float *v = Mem_Alloc(tempmempool, maxv * sizeof(float[3])); + float *vt = Mem_Alloc(tempmempool, maxvt * sizeof(float[2])); + float *vn = Mem_Alloc(tempmempool, maxvn * sizeof(float[3])); + objvertex_t vfirst, vprev, vcurrent; + float mins[3]; + float maxs[3]; +#if 0 + int hashindex; + int maxverthash = 65536, numverthash = 0; + int numhashindex = 65536; + struct objverthash_s + { + struct objverthash_s *next; + int s; + int v; + int vt; + int vn; + } + *hash, **verthash = Mem_Alloc(tempmempool, numhashindex * sizeof(*verthash)), *verthashdata = Mem_Alloc(tempmempool, maxverthash * sizeof(*verthashdata)), *oldverthashdata; +#endif + + dpsnprintf(materialname, sizeof(materialname), "%s", loadmodel->name); + + loadmodel->modeldatatypestring = "OBJ"; + + loadmodel->type = mod_obj; + loadmodel->soundfromcenter = true; + loadmodel->TraceBox = Mod_OBJ_TraceBox; + loadmodel->TraceLine = Mod_OBJ_TraceLine; + loadmodel->TracePoint = Mod_OBJ_TracePoint; + loadmodel->PointSuperContents = Mod_OBJ_PointSuperContents; + loadmodel->brush.TraceLineOfSight = Mod_OBJ_TraceLineOfSight; + loadmodel->brush.SuperContentsFromNativeContents = Mod_OBJ_SuperContentsFromNativeContents; + loadmodel->brush.NativeContentsFromSuperContents = Mod_OBJ_NativeContentsFromSuperContents; + loadmodel->brush.GetPVS = Mod_OBJ_GetPVS; + loadmodel->brush.FatPVS = Mod_OBJ_FatPVS; + loadmodel->brush.BoxTouchingPVS = Mod_OBJ_BoxTouchingPVS; + loadmodel->brush.BoxTouchingLeafPVS = Mod_OBJ_BoxTouchingLeafPVS; + loadmodel->brush.BoxTouchingVisibleLeafs = Mod_OBJ_BoxTouchingVisibleLeafs; + loadmodel->brush.FindBoxClusters = Mod_OBJ_FindBoxClusters; + loadmodel->brush.LightPoint = Mod_OBJ_LightPoint; + loadmodel->brush.FindNonSolidLocation = Mod_OBJ_FindNonSolidLocation; + loadmodel->brush.AmbientSoundLevelsForPoint = NULL; + loadmodel->brush.RoundUpToHullSize = NULL; + loadmodel->brush.PointInLeaf = Mod_OBJ_PointInLeaf; + loadmodel->Draw = R_Q1BSP_Draw; + loadmodel->DrawDepth = R_Q1BSP_DrawDepth; + loadmodel->DrawDebug = R_Q1BSP_DrawDebug; + loadmodel->DrawPrepass = R_Q1BSP_DrawPrepass; + loadmodel->GetLightInfo = R_Q1BSP_GetLightInfo; + loadmodel->CompileShadowMap = R_Q1BSP_CompileShadowMap; + loadmodel->DrawShadowMap = R_Q1BSP_DrawShadowMap; + loadmodel->CompileShadowVolume = R_Q1BSP_CompileShadowVolume; + loadmodel->DrawShadowVolume = R_Q1BSP_DrawShadowVolume; + loadmodel->DrawLight = R_Q1BSP_DrawLight; + + VectorClear(mins); + VectorClear(maxs); + + // parse the OBJ text now + for(;;) + { + if (!*text) + break; + linenumber++; + linelen = 0; + for (linelen = 0;text[linelen] && text[linelen] != '\r' && text[linelen] != '\n';linelen++) + line[linelen] = text[linelen]; + line[linelen] = 0; + for (argc = 0;argc < (int)(sizeof(argv)/sizeof(argv[0]));argc++) + argv[argc] = ""; + argc = 0; + s = line; + while (*s == ' ' || *s == '\t') + s++; + while (*s) + { + argv[argc++] = s; + while (*s > ' ') + s++; + if (!*s) + break; + *s++ = 0; + while (*s == ' ' || *s == '\t') + s++; + } + if (!argc) + continue; + if (argv[0][0] == '#') + continue; + if (!strcmp(argv[0], "v")) + { + if (maxv <= numv) + { + float *oldv = v; + maxv *= 2; + v = Mem_Alloc(tempmempool, maxv * sizeof(float[3])); + if (oldv) + { + memcpy(v, oldv, numv * sizeof(float[3])); + Mem_Free(oldv); + } + } + v[numv*3+0] = atof(argv[1]); + v[numv*3+1] = atof(argv[2]); + v[numv*3+2] = atof(argv[3]); + numv++; + } + else if (!strcmp(argv[0], "vt")) + { + if (maxvt <= numvt) + { + float *oldvt = vt; + maxvt *= 2; + vt = Mem_Alloc(tempmempool, maxvt * sizeof(float[2])); + if (oldvt) + { + memcpy(vt, oldvt, numvt * sizeof(float[2])); + Mem_Free(oldvt); + } + } + vt[numvt*2+0] = atof(argv[1]); + vt[numvt*2+1] = atof(argv[2]); + numvt++; + } + else if (!strcmp(argv[0], "vn")) + { + if (maxvn <= numvn) + { + float *oldvn = vn; + maxvn *= 2; + vn = Mem_Alloc(tempmempool, maxvn * sizeof(float[3])); + if (oldvn) + { + memcpy(vn, oldvn, numvn * sizeof(float[3])); + Mem_Free(oldvn); + } + } + vn[numvn*3+0] = atof(argv[1]); + vn[numvn*3+1] = atof(argv[2]); + vn[numvn*3+2] = atof(argv[3]); + numvn++; + } + else if (!strcmp(argv[0], "f")) + { + for (j = 1;j < argc;j++) + { + index1 = atoi(argv[j]); + while(argv[j][0] && argv[j][0] != '/') + argv[j]++; + if (argv[j][0]) + argv[j]++; + index2 = atoi(argv[j]); + while(argv[j][0] && argv[j][0] != '/') + argv[j]++; + if (argv[j][0]) + argv[j]++; + index3 = atoi(argv[j]); + // negative refers to a recent vertex + // zero means not specified + // positive means an absolute vertex index + if (index1 < 0) + index1 = numv - index1; + if (index2 < 0) + index2 = numvt - index2; + if (index3 < 0) + index3 = numvn - index3; + VectorCopy(v + 3*index1, vcurrent.v); + Vector2Copy(vt + 2*index2, vcurrent.vt); + VectorCopy(vn + 3*index3, vcurrent.vn); + if (numtriangles == 0) + { + VectorCopy(vcurrent.v, mins); + VectorCopy(vcurrent.v, maxs); + } + else + { + mins[0] = min(mins[0], vcurrent.v[0]); + mins[1] = min(mins[1], vcurrent.v[1]); + mins[2] = min(mins[2], vcurrent.v[2]); + maxs[0] = max(maxs[0], vcurrent.v[0]); + maxs[1] = max(maxs[1], vcurrent.v[1]); + maxs[2] = max(maxs[2], vcurrent.v[2]); + } + if (j == 1) + vfirst = vcurrent; + else if (j >= 3) + { + if (maxtriangles <= numtriangles) + { + objtriangle_t *oldtriangles = triangles; + maxtriangles *= 2; + triangles = Mem_Alloc(tempmempool, numtriangles * sizeof(*triangles)); + if (oldtriangles) + { + memcpy(triangles, oldtriangles, numtriangles * sizeof(*triangles)); + Mem_Free(oldtriangles); + } + } + triangles[numtriangles].textureindex = textureindex; + triangles[numtriangles].vertex[0] = vfirst; + triangles[numtriangles].vertex[1] = vprev; + triangles[numtriangles].vertex[2] = vcurrent; + numtriangles++; + } + vprev = vcurrent; + prev = index; + } + } + else if (!strcmp(argv[0], "o") || !strcmp(argv[0], "g")) + ; + else if (!!strcmp(argv[0], "usemtl")) + { + for (i = 0;i < numtextures;i++) + if (!strcmp(texturenames[numtextures], argv[1])) + break; + if (i < numtextures) + texture = textures + i; + else + { + if (maxtextures <= numtextures) + { + texture_t *oldtextures = textures; + maxtextures *= 2; + textures = Mem_Alloc(tempmempool, maxtextures * sizeof(*textures)); + if (oldtextures) + { + memcpy(textures, oldtextures, numtexutres * sizeof(*textures)); + Mem_Free(oldtextures); + } + } + textureindex = numtextures++; + texturenames[textureindex] = Mem_Alloc(tempmempool, strlen(argv[1]) + 1); + memcpy(texturenames[textureindex], argv[1], strlen(argv[1]) + 1); + } + } + text += linelen; + if (*text == '\r') + text++; + if (*text == '\n') + text++; + } + + // now that we have the OBJ data loaded as-is, we can convert it + + // load the textures + loadmodel->num_textures = numtextures; + loadmodel->data_textures = Mem_Alloc(loadmodel->mempool, loadmodel->num_textures * sizeof(texture_t)); + for (i = 0;i < numtextures;i++) + Mod_LoadTextureFromQ3Shader(loadmodel->data_textures + i, texturenames[i], true, true, TEXF_MIPMAP | TEXF_ALPHA | TEXF_PRECACHE | (r_picmipworld.integer ? TEXF_PICMIP : 0) | TEXF_COMPRESS); + + // free the texturenames array since we are now done with it + for (i = 0;i < numtextures;i++) + { + Mem_Free(texturenames[i]); + texturenames[i] = NULL; + } + Mem_Free(texturenames); + texturenames = NULL; + + // copy the model bounds, then enlarge the yaw and rotated bounds according to radius + VectorCopy(mins, loadmodel->normalmins); + VectorCopy(maxs, loadmodel->normalmaxs); + dist = max(fabs(loadmodel->normalmins[0]), fabs(loadmodel->normalmaxs[0])); + modelyawradius = max(fabs(loadmodel->normalmins[1]), fabs(loadmodel->normalmaxs[1])); + modelyawradius = dist*dist+modelyawradius*modelyawradius; + modelradius = max(fabs(loadmodel->normalmins[2]), fabs(loadmodel->normalmaxs[2])); + modelradius = modelyawradius + modelradius * modelradius; + modelyawradius = sqrt(modelyawradius); + modelradius = sqrt(modelradius); + loadmodel->yawmins[0] = loadmodel->yawmins[1] = -modelyawradius; + loadmodel->yawmins[2] = loadmodel->normalmins[2]; + loadmodel->yawmaxs[0] = loadmodel->yawmaxs[1] = modelyawradius; + loadmodel->yawmaxs[2] = loadmodel->normalmaxs[2]; + loadmodel->rotatedmins[0] = loadmodel->rotatedmins[1] = loadmodel->rotatedmins[2] = -modelradius; + loadmodel->rotatedmaxs[0] = loadmodel->rotatedmaxs[1] = loadmodel->rotatedmaxs[2] = modelradius; + loadmodel->radius = modelradius; + loadmodel->radius2 = modelradius * modelradius; + + // make sure the temp triangle buffer is big enough for BSP building + maxclippedtriangles = numtriangles*4; + if (numtriangles > 0) + { + clippedfronttriangles = Mem_Alloc(loadmodel->mempool, maxclippedtriangles * 2 * sizeof(objtriangle_t)); + clippedbacktriangles = clippedfronttriangles + maxclippedtriangles; + } + + // generate a rough BSP tree from triangle data, we don't have to be too careful here, it only has to define the basic areas of the map + loadmodel->brush.num_leafs = 0; + loadmodel->brush.num_nodes = 0; + Mem_ExpandableArray_NewArray(&nodesarray, loadmodel->mempool, sizeof(objnode_t), 1024); + rootnode = Mod_OBJ_BSPNodeForTriangles(triangles, numtriangles, mins, maxs, &nodesarray, maxclippedtriangles, clippedfronttriangles, clippedbacktriangles); + + // convert the BSP tree to mnode_t and mleaf_t structures and convert the triangles to msurface_t... + loadmodel->brush.data_leafs = Mem_Alloc(loadmodel->mempool, loadmodel->brush.num_leafs * sizeof(mleaf_t)); + loadmodel->brush.data_nodes = Mem_Alloc(loadmodel->mempool, loadmodel->brush.num_nodes * sizeof(mnode_t)); + loadmodel->brush.data_planes = Mem_Alloc(loadmodel->mempool, loadmodel->brush.num_nodes * sizeof(mplane_t)); + loadmodel->brush.num_leafs = 0; + loadmodel->brush.num_nodes = 0; + loadmodel->brush.num_planes = 0; + Mod_OBJ_ConvertAndFreeBSPNode(rootnode); + + if (clippedfronttriangles) + Mem_Free(clippedfronttriangles); + maxclippedtriangles = 0; + clippedfronttriangles = NULL; + clippedbacktriangles = NULL; + +--- NOTHING DONE PAST THIS POINT --- + + loadmodel->numskins = LittleLong(pinmodel->num_skins); + numxyz = LittleLong(pinmodel->num_xyz); + numst = LittleLong(pinmodel->num_st); + loadmodel->surfmesh.num_triangles = LittleLong(pinmodel->num_tris); + loadmodel->numframes = LittleLong(pinmodel->num_frames); + loadmodel->surfmesh.num_morphframes = loadmodel->numframes; + loadmodel->num_poses = loadmodel->surfmesh.num_morphframes; + skinwidth = LittleLong(pinmodel->skinwidth); + skinheight = LittleLong(pinmodel->skinheight); + iskinwidth = 1.0f / skinwidth; + iskinheight = 1.0f / skinheight; + + loadmodel->num_surfaces = 1; + loadmodel->nummodelsurfaces = loadmodel->num_surfaces; + data = (unsigned char *)Mem_Alloc(loadmodel->mempool, loadmodel->num_surfaces * sizeof(msurface_t) + loadmodel->num_surfaces * sizeof(int) + loadmodel->numframes * sizeof(animscene_t) + loadmodel->numframes * sizeof(float[6]) + loadmodel->surfmesh.num_triangles * sizeof(int[3]) + loadmodel->surfmesh.num_triangles * sizeof(int[3])); + loadmodel->data_surfaces = (msurface_t *)data;data += loadmodel->num_surfaces * sizeof(msurface_t); + loadmodel->sortedmodelsurfaces = (int *)data;data += loadmodel->num_surfaces * sizeof(int); + loadmodel->sortedmodelsurfaces[0] = 0; + loadmodel->animscenes = (animscene_t *)data;data += loadmodel->numframes * sizeof(animscene_t); + loadmodel->surfmesh.data_morphmd2framesize6f = (float *)data;data += loadmodel->numframes * sizeof(float[6]); + loadmodel->surfmesh.data_element3i = (int *)data;data += loadmodel->surfmesh.num_triangles * sizeof(int[3]); + loadmodel->surfmesh.data_neighbor3i = (int *)data;data += loadmodel->surfmesh.num_triangles * sizeof(int[3]); + + loadmodel->synctype = ST_RAND; + + // load the skins + inskin = (char *)(base + LittleLong(pinmodel->ofs_skins)); + skinfiles = Mod_LoadSkinFiles(); + if (skinfiles) + { + loadmodel->num_textures = loadmodel->num_surfaces * loadmodel->numskins; + loadmodel->num_texturesperskin = loadmodel->num_surfaces; + loadmodel->data_textures = (texture_t *)Mem_Alloc(loadmodel->mempool, loadmodel->num_surfaces * loadmodel->numskins * sizeof(texture_t)); + Mod_BuildAliasSkinsFromSkinFiles(loadmodel->data_textures, skinfiles, "default", ""); + Mod_FreeSkinFiles(skinfiles); + } + else if (loadmodel->numskins) + { + // skins found (most likely not a player model) + loadmodel->num_textures = loadmodel->num_surfaces * loadmodel->numskins; + loadmodel->num_texturesperskin = loadmodel->num_surfaces; + loadmodel->data_textures = (texture_t *)Mem_Alloc(loadmodel->mempool, loadmodel->num_surfaces * loadmodel->numskins * sizeof(texture_t)); + for (i = 0;i < loadmodel->numskins;i++, inskin += MD2_SKINNAME) + Mod_LoadTextureFromQ3Shader(loadmodel->data_textures + i * loadmodel->num_surfaces, inskin, true, true, (r_mipskins.integer ? TEXF_MIPMAP : 0) | TEXF_ALPHA | TEXF_PRECACHE | TEXF_PICMIP | TEXF_COMPRESS); + } + else + { + // no skins (most likely a player model) + loadmodel->numskins = 1; + loadmodel->num_textures = loadmodel->num_surfaces * loadmodel->numskins; + loadmodel->num_texturesperskin = loadmodel->num_surfaces; + loadmodel->data_textures = (texture_t *)Mem_Alloc(loadmodel->mempool, loadmodel->num_surfaces * loadmodel->numskins * sizeof(texture_t)); + Mod_BuildAliasSkinFromSkinFrame(loadmodel->data_textures, NULL); + } + + loadmodel->skinscenes = (animscene_t *)Mem_Alloc(loadmodel->mempool, sizeof(animscene_t) * loadmodel->numskins); + for (i = 0;i < loadmodel->numskins;i++) + { + loadmodel->skinscenes[i].firstframe = i; + loadmodel->skinscenes[i].framecount = 1; + loadmodel->skinscenes[i].loop = true; + loadmodel->skinscenes[i].framerate = 10; + } + + // load the triangles and stvert data + inst = (unsigned short *)(base + LittleLong(pinmodel->ofs_st)); + intri = (md2triangle_t *)(base + LittleLong(pinmodel->ofs_tris)); + md2verthash = (struct md2verthash_s **)Mem_Alloc(tempmempool, 65536 * sizeof(hash)); + md2verthashdata = (struct md2verthash_s *)Mem_Alloc(tempmempool, loadmodel->surfmesh.num_triangles * 3 * sizeof(*hash)); + // swap the triangle list + loadmodel->surfmesh.num_vertices = 0; + for (i = 0;i < loadmodel->surfmesh.num_triangles;i++) + { + for (j = 0;j < 3;j++) + { + xyz = (unsigned short) LittleShort (intri[i].index_xyz[j]); + st = (unsigned short) LittleShort (intri[i].index_st[j]); + if (xyz >= numxyz) + { + Con_Printf("%s has an invalid xyz index (%i) on triangle %i, resetting to 0\n", loadmodel->name, xyz, i); + xyz = 0; + } + if (st >= numst) + { + Con_Printf("%s has an invalid st index (%i) on triangle %i, resetting to 0\n", loadmodel->name, st, i); + st = 0; + } + hashindex = (xyz * 256 + st) & 65535; + for (hash = md2verthash[hashindex];hash;hash = hash->next) + if (hash->xyz == xyz && hash->st == st) + break; + if (hash == NULL) + { + hash = md2verthashdata + loadmodel->surfmesh.num_vertices++; + hash->xyz = xyz; + hash->st = st; + hash->next = md2verthash[hashindex]; + md2verthash[hashindex] = hash; + } + loadmodel->surfmesh.data_element3i[i*3+j] = (hash - md2verthashdata); + } + } + + vertremap = (int *)Mem_Alloc(loadmodel->mempool, loadmodel->surfmesh.num_vertices * sizeof(int)); + data = (unsigned char *)Mem_Alloc(loadmodel->mempool, loadmodel->surfmesh.num_vertices * sizeof(float[2]) + loadmodel->surfmesh.num_vertices * loadmodel->surfmesh.num_morphframes * sizeof(trivertx_t)); + loadmodel->surfmesh.data_texcoordtexture2f = (float *)data;data += loadmodel->surfmesh.num_vertices * sizeof(float[2]); + loadmodel->surfmesh.data_morphmdlvertex = (trivertx_t *)data;data += loadmodel->surfmesh.num_vertices * loadmodel->surfmesh.num_morphframes * sizeof(trivertx_t); + for (i = 0;i < loadmodel->surfmesh.num_vertices;i++) + { + int sts, stt; + hash = md2verthashdata + i; + vertremap[i] = hash->xyz; + sts = LittleShort(inst[hash->st*2+0]); + stt = LittleShort(inst[hash->st*2+1]); + if (sts < 0 || sts >= skinwidth || stt < 0 || stt >= skinheight) + { + Con_Printf("%s has an invalid skin coordinate (%i %i) on vert %i, changing to 0 0\n", loadmodel->name, sts, stt, i); + sts = 0; + stt = 0; + } + loadmodel->surfmesh.data_texcoordtexture2f[i*2+0] = sts * iskinwidth; + loadmodel->surfmesh.data_texcoordtexture2f[i*2+1] = stt * iskinheight; + } + + Mem_Free(md2verthash); + Mem_Free(md2verthashdata); + + // generate ushort elements array if possible + if (loadmodel->surfmesh.num_vertices <= 65536) + loadmodel->surfmesh.data_element3s = (unsigned short *)Mem_Alloc(loadmodel->mempool, sizeof(unsigned short[3]) * loadmodel->surfmesh.num_triangles); + + // load the frames + datapointer = (base + LittleLong(pinmodel->ofs_frames)); + for (i = 0;i < loadmodel->surfmesh.num_morphframes;i++) + { + int k; + trivertx_t *v; + trivertx_t *out; + pinframe = (md2frame_t *)datapointer; + datapointer += sizeof(md2frame_t); + // store the frame scale/translate into the appropriate array + for (j = 0;j < 3;j++) + { + loadmodel->surfmesh.data_morphmd2framesize6f[i*6+j] = LittleFloat(pinframe->scale[j]); + loadmodel->surfmesh.data_morphmd2framesize6f[i*6+3+j] = LittleFloat(pinframe->translate[j]); + } + // convert the vertices + v = (trivertx_t *)datapointer; + out = loadmodel->surfmesh.data_morphmdlvertex + i * loadmodel->surfmesh.num_vertices; + for (k = 0;k < loadmodel->surfmesh.num_vertices;k++) + out[k] = v[vertremap[k]]; + datapointer += numxyz * sizeof(trivertx_t); + + strlcpy(loadmodel->animscenes[i].name, pinframe->name, sizeof(loadmodel->animscenes[i].name)); + loadmodel->animscenes[i].firstframe = i; + loadmodel->animscenes[i].framecount = 1; + loadmodel->animscenes[i].framerate = 10; + loadmodel->animscenes[i].loop = true; + } + + Mem_Free(vertremap); + + Mod_MakeSortedSurfaces(loadmodel); + Mod_BuildTriangleNeighbors(loadmodel->surfmesh.data_neighbor3i, loadmodel->surfmesh.data_element3i, loadmodel->surfmesh.num_triangles); + Mod_Alias_CalculateBoundingBox(); + Mod_Alias_MorphMesh_CompileFrames(); + + surface = loadmodel->data_surfaces; + surface->texture = loadmodel->data_textures; + surface->num_firsttriangle = 0; + surface->num_triangles = loadmodel->surfmesh.num_triangles; + surface->num_firstvertex = 0; + surface->num_vertices = loadmodel->surfmesh.num_vertices; + + loadmodel->surfmesh.isanimated = false; + + 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]; +#endif +} + +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.