X-Git-Url: http://de.git.xonotic.org/?a=blobdiff_plain;f=model_brush.c;h=9eb87f13caca65e8535a6704c7a8621c543b9bba;hb=1eb6c9f7bf5f6966b47e25284e1fe3a60751107b;hp=ac8f68a2335cb1cb6c3a4214e540843aad635e1a;hpb=f5a3bb717b4692a49b1df7d6c5dddf7d67ad9e4f;p=xonotic%2Fdarkplaces.git diff --git a/model_brush.c b/model_brush.c index ac8f68a2..9eb87f13 100644 --- a/model_brush.c +++ b/model_brush.c @@ -27,8 +27,8 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. //cvar_t r_subdivide_size = {CVAR_SAVE, "r_subdivide_size", "128", "how large water polygons should be (smaller values produce more polygons which give better warping effects)"}; +cvar_t mod_bsp_portalize = {0, "mod_bsp_portalize", "1", "enables portal generation from BSP tree (may take several seconds per map), used by r_drawportals, r_useportalculling, r_shadow_realtime_world_compileportalculling, sv_cullentities_portal"}; cvar_t r_novis = {0, "r_novis", "0", "draws whole level, see also sv_cullentities_pvs 0"}; -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", "0", "minimum number of subdivisions (values above 0 will smooth curves that don't need it)"}; @@ -38,13 +38,31 @@ cvar_t r_subdivisions_collision_tolerance = {0, "r_subdivisions_collision_tolera 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 r_trippy = {0, "r_trippy", "0", "easter egg"}; +cvar_t r_fxaa = {CVAR_SAVE, "r_fxaa", "0", "fast approximate anti aliasing"}; +cvar_t mod_noshader_default_offsetmapping = {CVAR_SAVE, "mod_noshader_default_offsetmapping", "1", "use offsetmapping by default on all surfaces that are not using q3 shader files"}; +cvar_t mod_obj_orientation = {0, "mod_obj_orientation", "1", "fix orientation of OBJ models to the usual conventions (if zero, use coordinates as is)"}; +cvar_t mod_q2bsp_littransparentsurfaces = {0, "mod_q2bsp_littransparentsurfaces", "0", "allows lighting on rain in 3v3gloom3 and other cases of transparent surfaces that have lightmaps that were ignored by quake2"}; 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"}; -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"}; +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"}; +cvar_t mod_q3bsp_sRGBlightmaps = {0, "mod_q3bsp_sRGBlightmaps", "0", "treat lightmaps from Q3 maps as sRGB when vid_sRGB is active"}; +cvar_t mod_q3shader_default_offsetmapping = {CVAR_SAVE, "mod_q3shader_default_offsetmapping", "1", "use offsetmapping by default on all surfaces that are using q3 shader files"}; +cvar_t mod_q3shader_default_offsetmapping_scale = {CVAR_SAVE, "mod_q3shader_default_offsetmapping_scale", "1", "default scale used for offsetmapping"}; +cvar_t mod_q3shader_default_offsetmapping_bias = {CVAR_SAVE, "mod_q3shader_default_offsetmapping_bias", "0", "default bias used for offsetmapping"}; +cvar_t mod_q3shader_default_polygonfactor = {0, "mod_q3shader_default_polygonfactor", "0", "biases depth values of 'polygonoffset' shaders to prevent z-fighting artifacts"}; +cvar_t mod_q3shader_default_polygonoffset = {0, "mod_q3shader_default_polygonoffset", "-2", "biases depth values of 'polygonoffset' shaders to prevent z-fighting artifacts"}; +cvar_t mod_q3shader_force_addalpha = {0, "mod_q3shader_force_addalpha", "0", "treat GL_ONE GL_ONE (or add) blendfunc as GL_SRC_ALPHA GL_ONE for compatibility with older DarkPlaces releases"}; +cvar_t mod_q3shader_force_terrain_alphaflag = {0, "mod_q3shader_force_terrain_alphaflag", "0", "for multilayered terrain shaders force TEXF_ALPHA flag on both layers"}; + +cvar_t mod_q1bsp_polygoncollisions = {0, "mod_q1bsp_polygoncollisions", "0", "disables use of precomputed cliphulls and instead collides with polygons (uses Bounding Interval Hierarchy optimizations)"}; +cvar_t mod_collision_bih = {0, "mod_collision_bih", "1", "enables use of generated Bounding Interval Hierarchy tree instead of compiled bsp tree in collision code"}; +cvar_t mod_recalculatenodeboxes = {0, "mod_recalculatenodeboxes", "1", "enables use of generated node bounding boxes based on BSP tree portal reconstruction, rather than the node boxes supplied by the map compiler"}; static texture_t mod_q1bsp_texture_solid; static texture_t mod_q1bsp_texture_sky; @@ -52,11 +70,13 @@ static texture_t mod_q1bsp_texture_lava; static texture_t mod_q1bsp_texture_slime; static texture_t mod_q1bsp_texture_water; +static qboolean Mod_Q3BSP_TraceLineOfSight(struct model_s *model, const vec3_t start, const vec3_t end, const vec3_t acceptmins, const vec3_t acceptmaxs); + void Mod_BrushInit(void) { // Cvar_RegisterVariable(&r_subdivide_size); + Cvar_RegisterVariable(&mod_bsp_portalize); Cvar_RegisterVariable(&r_novis); - Cvar_RegisterVariable(&r_picmipworld); Cvar_RegisterVariable(&r_nosurftextures); Cvar_RegisterVariable(&r_subdivisions_tolerance); Cvar_RegisterVariable(&r_subdivisions_mintess); @@ -66,6 +86,11 @@ void Mod_BrushInit(void) Cvar_RegisterVariable(&r_subdivisions_collision_mintess); Cvar_RegisterVariable(&r_subdivisions_collision_maxtess); Cvar_RegisterVariable(&r_subdivisions_collision_maxvertices); + Cvar_RegisterVariable(&r_trippy); + Cvar_RegisterVariable(&r_fxaa); + Cvar_RegisterVariable(&mod_noshader_default_offsetmapping); + Cvar_RegisterVariable(&mod_obj_orientation); + Cvar_RegisterVariable(&mod_q2bsp_littransparentsurfaces); Cvar_RegisterVariable(&mod_q3bsp_curves_collisions); Cvar_RegisterVariable(&mod_q3bsp_curves_collisions_stride); Cvar_RegisterVariable(&mod_q3bsp_curves_stride); @@ -73,6 +98,23 @@ void Mod_BrushInit(void) Cvar_RegisterVariable(&mod_q3bsp_debugtracebrush); Cvar_RegisterVariable(&mod_q3bsp_lightmapmergepower); Cvar_RegisterVariable(&mod_q3bsp_nolightmaps); + Cvar_RegisterVariable(&mod_q3bsp_sRGBlightmaps); + Cvar_RegisterVariable(&mod_q3bsp_tracelineofsight_brushes); + Cvar_RegisterVariable(&mod_q3shader_default_offsetmapping); + Cvar_RegisterVariable(&mod_q3shader_default_offsetmapping_scale); + Cvar_RegisterVariable(&mod_q3shader_default_offsetmapping_bias); + Cvar_RegisterVariable(&mod_q3shader_default_polygonfactor); + Cvar_RegisterVariable(&mod_q3shader_default_polygonoffset); + Cvar_RegisterVariable(&mod_q3shader_force_addalpha); + Cvar_RegisterVariable(&mod_q3shader_force_terrain_alphaflag); + Cvar_RegisterVariable(&mod_q1bsp_polygoncollisions); + Cvar_RegisterVariable(&mod_collision_bih); + Cvar_RegisterVariable(&mod_recalculatenodeboxes); + + // these games were made for older DP engines and are no longer + // maintained; use this hack to show their textures properly + if(gamemode == GAME_NEXUIZ) + Cvar_SetQuick(&mod_q3shader_force_addalpha, "1"); memset(&mod_q1bsp_texture_solid, 0, sizeof(mod_q1bsp_texture_solid)); strlcpy(mod_q1bsp_texture_solid.name, "solid" , sizeof(mod_q1bsp_texture_solid.name)); @@ -142,7 +184,7 @@ static int Mod_Q1BSP_FindBoxClusters(dp_model_t *model, const vec3_t mins, const 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 @@ -207,7 +249,7 @@ static int Mod_Q1BSP_BoxTouchingPVS(dp_model_t *model, const unsigned char *pvs, 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 @@ -278,7 +320,7 @@ static int Mod_Q1BSP_BoxTouchingLeafPVS(dp_model_t *model, const unsigned char * 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 @@ -349,7 +391,7 @@ static int Mod_Q1BSP_BoxTouchingVisibleLeafs(dp_model_t *model, const unsigned c 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 @@ -520,17 +562,17 @@ static void Mod_Q1BSP_FindNonSolidLocation_r_Leaf(findnonsolidlocationinfo_t *in surface = info->model->data_surfaces + *mark; if (surface->texture->supercontents & SUPERCONTENTS_SOLID) { - if(surface->num_bboxstride) + if(surface->deprecatedq3num_bboxstride > 0) { int i, cnt, tri; - cnt = (surface->num_triangles + surface->num_bboxstride - 1) / surface->num_bboxstride; + cnt = (surface->num_triangles + surface->deprecatedq3num_bboxstride - 1) / surface->deprecatedq3num_bboxstride; for(i = 0; i < cnt; ++i) { - if(BoxesOverlap(surface->data_bbox6f + i * 6, surface->data_bbox6f + i * 6 + 3, info->absmin, info->absmax)) + if(BoxesOverlap(surface->deprecatedq3data_bbox6f + i * 6, surface->deprecatedq3data_bbox6f + i * 6 + 3, info->absmin, info->absmax)) { - for(k = 0; k < surface->num_bboxstride; ++k) + for(k = 0; k < surface->deprecatedq3num_bboxstride; ++k) { - tri = i * surface->num_bboxstride + k; + tri = i * surface->deprecatedq3num_bboxstride + k; if(tri >= surface->num_triangles) break; Mod_Q1BSP_FindNonSolidLocation_r_Triangle(info, surface, tri); @@ -598,7 +640,7 @@ static void Mod_Q1BSP_FindNonSolidLocation(dp_model_t *model, const vec3_t in, v VectorCopy(info.center, out); } -int Mod_Q1BSP_SuperContentsFromNativeContents(dp_model_t *model, int nativecontents) +int Mod_Q1BSP_SuperContentsFromNativeContents(int nativecontents) { switch(nativecontents) { @@ -618,7 +660,7 @@ int Mod_Q1BSP_SuperContentsFromNativeContents(dp_model_t *model, int nativeconte return 0; } -int Mod_Q1BSP_NativeContentsFromSuperContents(dp_model_t *model, int supercontents) +int Mod_Q1BSP_NativeContentsFromSuperContents(int supercontents) { if (supercontents & (SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY)) return CONTENTS_SOLID; @@ -655,7 +697,6 @@ RecursiveHullCheckTraceInfo_t; #define HULLCHECKSTATE_SOLID 1 #define HULLCHECKSTATE_DONE 2 -extern cvar_t collision_prefernudgedfraction; static int Mod_Q1BSP_RecursiveHullCheck(RecursiveHullCheckTraceInfo_t *t, int num, double p1f, double p2f, double p1[3], double p2[3]) { // status variables, these don't need to be saved on the stack when @@ -667,156 +708,151 @@ static int Mod_Q1BSP_RecursiveHullCheck(RecursiveHullCheckTraceInfo_t *t, int nu // variables that need to be stored on the stack when recursing mclipnode_t *node; - int side; + int p1side, p2side; double midf, mid[3]; - // LordHavoc: a goto! everyone flee in terror... :) -loc0: - // check for empty - if (num < 0) - { - num = Mod_Q1BSP_SuperContentsFromNativeContents(NULL, num); - if (!t->trace->startfound) - { - t->trace->startfound = true; - t->trace->startsupercontents |= num; - } - if (num & SUPERCONTENTS_LIQUIDSMASK) - t->trace->inwater = true; - if (num == 0) - t->trace->inopen = true; - if (num & SUPERCONTENTS_SOLID) - t->trace->hittexture = &mod_q1bsp_texture_solid; - else if (num & SUPERCONTENTS_SKY) - t->trace->hittexture = &mod_q1bsp_texture_sky; - else if (num & SUPERCONTENTS_LAVA) - t->trace->hittexture = &mod_q1bsp_texture_lava; - else if (num & SUPERCONTENTS_SLIME) - t->trace->hittexture = &mod_q1bsp_texture_slime; - else - t->trace->hittexture = &mod_q1bsp_texture_water; - t->trace->hitq3surfaceflags = t->trace->hittexture->surfaceflags; - t->trace->hitsupercontents = num; - if (num & t->trace->hitsupercontentsmask) + // keep looping until we hit a leaf + while (num >= 0) + { + // find the point distances + node = t->hull->clipnodes + num; + plane = t->hull->planes + node->planenum; + + // axial planes can be calculated more quickly without the DotProduct + if (plane->type < 3) { - // if the first leaf is solid, set startsolid - if (t->trace->allsolid) - t->trace->startsolid = true; -#if COLLISIONPARANOID >= 3 - Con_Print("S"); -#endif - return HULLCHECKSTATE_SOLID; + t1 = p1[plane->type] - plane->dist; + t2 = p2[plane->type] - plane->dist; } else { - t->trace->allsolid = false; -#if COLLISIONPARANOID >= 3 - Con_Print("E"); -#endif - return HULLCHECKSTATE_EMPTY; + t1 = DotProduct (plane->normal, p1) - plane->dist; + t2 = DotProduct (plane->normal, p2) - plane->dist; } - } - - // find the point distances - node = t->hull->clipnodes + num; - plane = t->hull->planes + node->planenum; - 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; - } + // negative plane distances indicate children[1] (behind plane) + p1side = t1 < 0; + p2side = t2 < 0; - if (t1 < 0) - { - if (t2 < 0) + // if the line starts and ends on the same side of the plane, recurse + // into that child instantly + if (p1side == p2side) { #if COLLISIONPARANOID >= 3 - Con_Print("<"); + if (p1side) + Con_Print("<"); + else + Con_Print(">"); #endif - num = node->children[1]; - goto loc0; + // loop back and process the start child + num = node->children[p1side]; } - side = 1; - } - else - { - if (t2 >= 0) + else { + // find the midpoint where the line crosses the plane, use the + // original line for best accuracy #if COLLISIONPARANOID >= 3 - Con_Print(">"); + Con_Print("M"); #endif - num = node->children[0]; - goto loc0; - } - side = 0; - } + if (plane->type < 3) + { + t1 = t->start[plane->type] - plane->dist; + t2 = t->end[plane->type] - plane->dist; + } + else + { + t1 = DotProduct (plane->normal, t->start) - plane->dist; + t2 = DotProduct (plane->normal, t->end) - plane->dist; + } + midf = t1 / (t1 - t2); + midf = bound(p1f, midf, p2f); + VectorMA(t->start, midf, t->dist, mid); + + // we now have a mid point, essentially splitting the line into + // the segments in the near child and the far child, we can now + // recurse those in order and get their results + + // recurse both sides, front side first + ret = Mod_Q1BSP_RecursiveHullCheck(t, node->children[p1side], p1f, midf, p1, mid); + // if this side is not empty, return what it is (solid or done) + if (ret != HULLCHECKSTATE_EMPTY) + return ret; + + ret = Mod_Q1BSP_RecursiveHullCheck(t, node->children[p2side], midf, p2f, mid, p2); + // if other side is not solid, return what it is (empty or done) + if (ret != HULLCHECKSTATE_SOLID) + return ret; + + // front is air and back is solid, this is the impact point... + + // copy the plane information, flipping it if needed + if (p1side) + { + t->trace->plane.dist = -plane->dist; + VectorNegate (plane->normal, t->trace->plane.normal); + } + else + { + t->trace->plane.dist = plane->dist; + VectorCopy (plane->normal, t->trace->plane.normal); + } + + // calculate the return fraction which is nudged off the surface a bit + t1 = DotProduct(t->trace->plane.normal, t->start) - t->trace->plane.dist; + t2 = DotProduct(t->trace->plane.normal, t->end) - t->trace->plane.dist; + midf = (t1 - collision_impactnudge.value) / (t1 - t2); + t->trace->fraction = bound(0, midf, 1); - // the line intersects, find intersection point - // LordHavoc: this uses the original trace for maximum accuracy #if COLLISIONPARANOID >= 3 - Con_Print("M"); + Con_Print("D"); #endif - if (plane->type < 3) - { - t1 = t->start[plane->type] - plane->dist; - t2 = t->end[plane->type] - plane->dist; - } - else - { - t1 = DotProduct (plane->normal, t->start) - plane->dist; - t2 = DotProduct (plane->normal, t->end) - plane->dist; + return HULLCHECKSTATE_DONE; + } } - midf = t1 / (t1 - t2); - midf = bound(p1f, midf, p2f); - VectorMA(t->start, midf, t->dist, mid); - - // recurse both sides, front side first - ret = Mod_Q1BSP_RecursiveHullCheck(t, node->children[side], p1f, midf, p1, mid); - // if this side is not empty, return what it is (solid or done) - if (ret != HULLCHECKSTATE_EMPTY) - return ret; - - ret = Mod_Q1BSP_RecursiveHullCheck(t, node->children[side ^ 1], midf, p2f, mid, p2); - // if other side is not solid, return what it is (empty or done) - if (ret != HULLCHECKSTATE_SOLID) - return ret; + // we reached a leaf contents - // front is air and back is solid, this is the impact point... - if (side) + // check for empty + num = Mod_Q1BSP_SuperContentsFromNativeContents(num); + if (!t->trace->startfound) { - t->trace->plane.dist = -plane->dist; - VectorNegate (plane->normal, t->trace->plane.normal); + t->trace->startfound = true; + t->trace->startsupercontents |= num; } + if (num & SUPERCONTENTS_LIQUIDSMASK) + t->trace->inwater = true; + if (num == 0) + t->trace->inopen = true; + if (num & SUPERCONTENTS_SOLID) + t->trace->hittexture = &mod_q1bsp_texture_solid; + else if (num & SUPERCONTENTS_SKY) + t->trace->hittexture = &mod_q1bsp_texture_sky; + else if (num & SUPERCONTENTS_LAVA) + t->trace->hittexture = &mod_q1bsp_texture_lava; + else if (num & SUPERCONTENTS_SLIME) + t->trace->hittexture = &mod_q1bsp_texture_slime; else + t->trace->hittexture = &mod_q1bsp_texture_water; + t->trace->hitq3surfaceflags = t->trace->hittexture->surfaceflags; + t->trace->hitsupercontents = num; + if (num & t->trace->hitsupercontentsmask) { - t->trace->plane.dist = plane->dist; - VectorCopy (plane->normal, t->trace->plane.normal); + // if the first leaf is solid, set startsolid + if (t->trace->allsolid) + t->trace->startsolid = true; +#if COLLISIONPARANOID >= 3 + Con_Print("S"); +#endif + return HULLCHECKSTATE_SOLID; } - - // calculate the true fraction - t1 = DotProduct(t->trace->plane.normal, t->start) - t->trace->plane.dist; - t2 = DotProduct(t->trace->plane.normal, t->end) - t->trace->plane.dist; - midf = t1 / (t1 - t2); - t->trace->realfraction = bound(0, midf, 1); - - // calculate the return fraction which is nudged off the surface a bit - midf = (t1 - DIST_EPSILON) / (t1 - t2); - t->trace->fraction = bound(0, midf, 1); - - if (collision_prefernudgedfraction.integer) - t->trace->realfraction = t->trace->fraction; - + else + { + t->trace->allsolid = false; #if COLLISIONPARANOID >= 3 - Con_Print("D"); + Con_Print("E"); #endif - return HULLCHECKSTATE_DONE; + return HULLCHECKSTATE_EMPTY; + } } //#if COLLISIONPARANOID < 2 @@ -832,7 +868,7 @@ static int Mod_Q1BSP_RecursiveHullCheckPoint(RecursiveHullCheckTraceInfo_t *t, i 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); + num = Mod_Q1BSP_SuperContentsFromNativeContents(num); t->trace->startsupercontents |= num; if (num & SUPERCONTENTS_LIQUIDSMASK) t->trace->inwater = true; @@ -851,7 +887,7 @@ static int Mod_Q1BSP_RecursiveHullCheckPoint(RecursiveHullCheckTraceInfo_t *t, i } //#endif -static void Mod_Q1BSP_TracePoint(struct model_s *model, int frame, trace_t *trace, const vec3_t start, 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, int skipsupercontentsmask, int skipmaterialflagsmask) { RecursiveHullCheckTraceInfo_t rhc; @@ -859,7 +895,6 @@ static void Mod_Q1BSP_TracePoint(struct model_s *model, int frame, trace_t *trac 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); @@ -867,13 +902,22 @@ static void Mod_Q1BSP_TracePoint(struct model_s *model, int frame, trace_t *trac Mod_Q1BSP_RecursiveHullCheckPoint(&rhc, rhc.hull->firstclipnode); } -static void Mod_Q1BSP_TraceLine(struct model_s *model, int frame, trace_t *trace, const vec3_t start, const vec3_t end, int hitsupercontentsmask) +static void Mod_Q1BSP_TraceLineAgainstSurfaces(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, int skipsupercontentsmask, int skipmaterialflagsmask); + +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, int skipsupercontentsmask, int skipmaterialflagsmask) { RecursiveHullCheckTraceInfo_t rhc; if (VectorCompare(start, end)) { - Mod_Q1BSP_TracePoint(model, frame, trace, start, hitsupercontentsmask); + Mod_Q1BSP_TracePoint(model, frameblend, skeleton, trace, start, hitsupercontentsmask, skipsupercontentsmask, skipmaterialflagsmask); + return; + } + + // sometimes we want to traceline against polygons so we can report the texture that was hit rather than merely a contents, but using this method breaks one of negke's maps so it must be a cvar check... + if (sv_gameplayfix_q1bsptracelinereportstexture.integer) + { + Mod_Q1BSP_TraceLineAgainstSurfaces(model, frameblend, skeleton, trace, start, end, hitsupercontentsmask, skipsupercontentsmask, skipmaterialflagsmask); return; } @@ -881,8 +925,9 @@ static void Mod_Q1BSP_TraceLine(struct model_s *model, int frame, trace_t *trace memset(trace, 0, sizeof(trace_t)); rhc.trace = trace; rhc.trace->hitsupercontentsmask = hitsupercontentsmask; + rhc.trace->skipsupercontentsmask = skipsupercontentsmask; + rhc.trace->skipmaterialflagsmask = skipmaterialflagsmask; rhc.trace->fraction = 1; - rhc.trace->realfraction = 1; rhc.trace->allsolid = true; rhc.hull = &model->brushq1.hulls[0]; // 0x0x0 VectorCopy(start, rhc.start); @@ -899,8 +944,9 @@ static void Mod_Q1BSP_TraceLine(struct model_s *model, int frame, trace_t *trace memset(&testtrace, 0, sizeof(trace_t)); rhc.trace = &testtrace; rhc.trace->hitsupercontentsmask = hitsupercontentsmask; + rhc.trace->skipsupercontentsmask = skipsupercontentsmask; + rhc.trace->skipmaterialflagsmask = skipmaterialflagsmask; rhc.trace->fraction = 1; - rhc.trace->realfraction = 1; rhc.trace->allsolid = true; VectorCopy(test, rhc.start); VectorCopy(test, rhc.end); @@ -919,7 +965,7 @@ static void Mod_Q1BSP_TraceLine(struct model_s *model, int frame, trace_t *trace #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_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, int skipsupercontentsmask, int skipmaterialflagsmask) { // this function currently only supports same size start and end double boxsize[3]; @@ -928,9 +974,9 @@ static void Mod_Q1BSP_TraceBox(struct model_s *model, int frame, trace_t *trace, if (VectorCompare(boxmins, boxmaxs)) { if (VectorCompare(start, end)) - Mod_Q1BSP_TracePoint(model, frame, trace, start, hitsupercontentsmask); + Mod_Q1BSP_TracePoint(model, frameblend, skeleton, trace, start, hitsupercontentsmask, skipsupercontentsmask, skipmaterialflagsmask); else - Mod_Q1BSP_TraceLine(model, frame, trace, start, end, hitsupercontentsmask); + Mod_Q1BSP_TraceLine(model, frameblend, skeleton, trace, start, end, hitsupercontentsmask, skipsupercontentsmask, skipmaterialflagsmask); return; } @@ -938,8 +984,9 @@ static void Mod_Q1BSP_TraceBox(struct model_s *model, int frame, trace_t *trace, memset(trace, 0, sizeof(trace_t)); rhc.trace = trace; rhc.trace->hitsupercontentsmask = hitsupercontentsmask; + rhc.trace->skipsupercontentsmask = skipsupercontentsmask; + rhc.trace->skipmaterialflagsmask = skipmaterialflagsmask; rhc.trace->fraction = 1; - rhc.trace->realfraction = 1; rhc.trace->allsolid = true; VectorSubtract(boxmaxs, boxmins, boxsize); if (boxsize[0] < 3) @@ -981,8 +1028,9 @@ static void Mod_Q1BSP_TraceBox(struct model_s *model, int frame, trace_t *trace, memset(&testtrace, 0, sizeof(trace_t)); rhc.trace = &testtrace; rhc.trace->hitsupercontentsmask = hitsupercontentsmask; + rhc.trace->skipsupercontentsmask = skipsupercontentsmask; + rhc.trace->skipmaterialflagsmask = skipmaterialflagsmask; rhc.trace->fraction = 1; - rhc.trace->realfraction = 1; rhc.trace->allsolid = true; VectorCopy(test, rhc.start); VectorCopy(test, rhc.end); @@ -1012,14 +1060,16 @@ static int Mod_Q1BSP_PointSuperContents(struct model_s *model, int frame, const 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); + return Mod_Q1BSP_SuperContentsFromNativeContents(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) +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 skipsupercontentsmask, int skipmaterialflagsmask, int boxsupercontents, int boxq3surfaceflags, const 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; @@ -1048,8 +1098,9 @@ void Collision_ClipTrace_Box(trace_t *trace, const vec3_t cmins, const vec3_t cm cbox_planes[5].q3surfaceflags = boxq3surfaceflags;cbox_planes[5].texture = boxtexture; memset(trace, 0, sizeof(trace_t)); trace->hitsupercontentsmask = hitsupercontentsmask; + trace->skipsupercontentsmask = skipsupercontentsmask; + trace->skipmaterialflagsmask = skipmaterialflagsmask; trace->fraction = 1; - trace->realfraction = 1; Collision_TraceLineBrushFloat(trace, start, end, &cbox, &cbox); #else RecursiveHullCheckTraceInfo_t rhc; @@ -1106,8 +1157,9 @@ void Collision_ClipTrace_Box(trace_t *trace, const vec3_t cmins, const vec3_t cm rhc.hull = &box_hull; rhc.trace = trace; rhc.trace->hitsupercontentsmask = hitsupercontentsmask; + rhc.trace->skipsupercontentsmask = skipsupercontentsmask; + rhc.trace->skipmaterialflagsmask = skipmaterialflagsmask; rhc.trace->fraction = 1; - rhc.trace->realfraction = 1; rhc.trace->allsolid = true; VectorCopy(start, rhc.start); VectorCopy(end, rhc.end); @@ -1119,15 +1171,17 @@ void Collision_ClipTrace_Box(trace_t *trace, const vec3_t cmins, const vec3_t cm #endif } -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) +void Collision_ClipTrace_Point(trace_t *trace, const vec3_t cmins, const vec3_t cmaxs, const vec3_t start, int hitsupercontentsmask, int skipsupercontentsmask, int skipmaterialflagsmask, int boxsupercontents, int boxq3surfaceflags, const texture_t *boxtexture) { memset(trace, 0, sizeof(trace_t)); trace->fraction = 1; - trace->realfraction = 1; + trace->hitsupercontentsmask = hitsupercontentsmask; + trace->skipsupercontentsmask = skipsupercontentsmask; + trace->skipmaterialflagsmask = skipmaterialflagsmask; if (BoxesOverlap(start, start, cmins, cmaxs)) { trace->startsupercontents |= boxsupercontents; - if (hitsupercontentsmask & boxsupercontents) + if ((hitsupercontentsmask & boxsupercontents) && !(skipsupercontentsmask & boxsupercontents)) { trace->startsolid = true; trace->allsolid = true; @@ -1135,74 +1189,11 @@ void Collision_ClipTrace_Point(trace_t *trace, const vec3_t cmins, const vec3_t } } -static int Mod_Q1BSP_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_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) +static qboolean Mod_Q1BSP_TraceLineOfSight(struct model_s *model, const vec3_t start, const vec3_t end, const vec3_t acceptmins, const vec3_t acceptmaxs) { - // 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; + Mod_Q1BSP_TraceLine(model, NULL, NULL, &trace, start, end, SUPERCONTENTS_VISBLOCKERMASK, 0, MATERIALFLAGMASK_TRANSLUCENT); + return trace.fraction == 1 || BoxesOverlap(trace.endpos, trace.endpos, acceptmins, acceptmaxs); } 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) @@ -1211,52 +1202,50 @@ static int Mod_Q1BSP_LightPoint_RecursiveBSPNode(dp_model_t *model, vec3_t ambie float front, back; float mid, distz = endz - startz; -loc0: - if (!node->plane) - return false; // didn't hit anything - - switch (node->plane->type) + while (node->plane) { - case PLANE_X: - node = node->children[x < node->plane->dist]; - goto loc0; - case PLANE_Y: - node = node->children[y < node->plane->dist]; - goto loc0; - case PLANE_Z: - side = startz < node->plane->dist; - if ((endz < node->plane->dist) == side) - { - node = node->children[side]; - goto loc0; - } - // found an intersection - mid = node->plane->dist; - break; - default: - back = front = x * node->plane->normal[0] + y * node->plane->normal[1]; - front += startz * node->plane->normal[2]; - back += endz * node->plane->normal[2]; - side = front < node->plane->dist; - if ((back < node->plane->dist) == side) - { - node = node->children[side]; - goto loc0; + switch (node->plane->type) + { + case PLANE_X: + node = node->children[x < node->plane->dist]; + continue; // loop back and process the new node + case PLANE_Y: + node = node->children[y < node->plane->dist]; + continue; // loop back and process the new node + case PLANE_Z: + side = startz < node->plane->dist; + if ((endz < node->plane->dist) == side) + { + node = node->children[side]; + continue; // loop back and process the new node + } + // found an intersection + mid = node->plane->dist; + break; + default: + back = front = x * node->plane->normal[0] + y * node->plane->normal[1]; + front += startz * node->plane->normal[2]; + back += endz * node->plane->normal[2]; + side = front < node->plane->dist; + if ((back < node->plane->dist) == side) + { + node = node->children[side]; + continue; // loop back and process the new node + } + // found an intersection + mid = startz + distz * (front - node->plane->dist) / (front - back); + break; } - // found an intersection - mid = startz + distz * (front - node->plane->dist) / (front - back); - break; - } - // go down front side - if (node->children[side]->plane && Mod_Q1BSP_LightPoint_RecursiveBSPNode(model, ambientcolor, diffusecolor, diffusenormal, node->children[side], x, y, startz, mid)) - return true; // hit something - else - { + // go down front side + if (node->children[side]->plane && Mod_Q1BSP_LightPoint_RecursiveBSPNode(model, ambientcolor, diffusecolor, diffusenormal, node->children[side], x, y, startz, mid)) + return true; // hit something + // check for impact on this node if (node->numsurfaces) { - int i, dsi, dti, lmwidth, lmheight; + unsigned int i; + int dsi, dti, lmwidth, lmheight; float ds, dt; msurface_t *surface; unsigned char *lightmap; @@ -1268,7 +1257,7 @@ loc0: surface = model->data_surfaces + node->firstsurface; for (i = 0;i < node->numsurfaces;i++, surface++) { - if (!(surface->texture->basematerialflags & MATERIALFLAG_WALL) || !surface->lightmapinfo->samples) + if (!(surface->texture->basematerialflags & MATERIALFLAG_WALL) || !surface->lightmapinfo || !surface->lightmapinfo->samples) continue; // no lightmaps // location we want to sample in the lightmap @@ -1276,22 +1265,44 @@ loc0: dt = ((x * surface->lightmapinfo->texinfo->vecs[1][0] + y * surface->lightmapinfo->texinfo->vecs[1][1] + mid * surface->lightmapinfo->texinfo->vecs[1][2] + surface->lightmapinfo->texinfo->vecs[1][3]) - surface->lightmapinfo->texturemins[1]) * 0.0625f; // check the bounds - dsi = (int)ds; - dti = (int)dt; + // thanks to jitspoe for pointing out that this int cast was + // rounding toward zero, so we floor it + dsi = (int)floor(ds); + dti = (int)floor(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) + // we have to tolerate a position of lmwidth-1 for some rare + // cases - in which case the sampling position still gets + // clamped but the color gets interpolated to that edge. + if (dsi >= 0 && dsi < lmwidth && dti >= 0 && dti < lmheight) { + // in the rare cases where we're sampling slightly off + // the polygon, clamp the sampling position (we can still + // interpolate outside it, where it becomes extrapolation) + if (dsi < 0) + dsi = 0; + if (dti < 0) + dti = 0; + if (dsi > lmwidth-2) + dsi = lmwidth-2; + if (dti > lmheight-2) + dti = lmheight-2; + // calculate bilinear interpolation factors - // and also multiply by fixedpoint conversion factors + // and also multiply by fixedpoint conversion factors to + // compensate for lightmaps being 0-255 (as 0-2), we use + // r_refdef.scene.rtlightstylevalue here which is already + // 0.000-2.148 range + // (if we used r_refdef.scene.lightstylevalue this + // divisor would be 32768 rather than 128) 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); + w00 = (1 - dsfrac) * (1 - dtfrac) * (1.0f / 128.0f); + w01 = ( dsfrac) * (1 - dtfrac) * (1.0f / 128.0f); + w10 = (1 - dsfrac) * ( dtfrac) * (1.0f / 128.0f); + w11 = ( dsfrac) * ( dtfrac) * (1.0f / 128.0f); // values for pointer math line3 = lmwidth * 3; // LordHavoc: *3 for colored lighting @@ -1303,7 +1314,7 @@ loc0: // bilinear filter each lightmap style, and sum them for (maps = 0;maps < MAXLIGHTMAPS && surface->lightmapinfo->styles[maps] != 255;maps++) { - scale = r_refdef.scene.lightstylevalue[surface->lightmapinfo->styles[maps]]; + scale = r_refdef.scene.rtlightstylevalue[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); @@ -1320,11 +1331,14 @@ loc0: node = node->children[side ^ 1]; startz = mid; distz = endz - startz; - goto loc0; + // loop back and process the new node } + + // did not hit anything + return false; } -void Mod_Q1BSP_LightPoint(dp_model_t *model, const vec3_t p, vec3_t ambientcolor, vec3_t diffusecolor, vec3_t diffusenormal) +static 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); @@ -1339,158 +1353,381 @@ void Mod_Q1BSP_LightPoint(dp_model_t *model, const vec3_t p, vec3_t ambientcolor Mod_Q1BSP_LightPoint_RecursiveBSPNode(model, ambientcolor, diffusecolor, diffusenormal, model->brush.data_nodes + model->brushq1.hulls[0].firstclipnode, p[0], p[1], p[2] + 0.125, p[2] - 65536); } -static void Mod_Q1BSP_DecompressVis(const unsigned char *in, const unsigned char *inend, unsigned char *out, unsigned char *outend) +static const texture_t *Mod_Q1BSP_TraceLineAgainstSurfacesFindTextureOnNode(RecursiveHullCheckTraceInfo_t *t, const dp_model_t *model, const mnode_t *node, double mid[3]) { - int c; - unsigned char *outstart = out; - while (out < outend) - { - if (in == inend) - { - Con_Printf("Mod_Q1BSP_DecompressVis: input underrun on model \"%s\" (decompressed %i of %i output bytes)\n", loadmodel->name, (int)(out - outstart), (int)(outend - outstart)); - return; - } - c = *in++; - if (c) - *out++ = c; - else - { - if (in == inend) - { - Con_Printf("Mod_Q1BSP_DecompressVis: input underrun (during zero-run) on model \"%s\" (decompressed %i of %i output bytes)\n", loadmodel->name, (int)(out - outstart), (int)(outend - outstart)); - return; - } - for (c = *in++;c > 0;c--) - { - if (out == outend) - { - Con_Printf("Mod_Q1BSP_DecompressVis: output overrun on model \"%s\" (decompressed %i of %i output bytes)\n", loadmodel->name, (int)(out - outstart), (int)(outend - outstart)); - return; - } - *out++ = 0; - } + unsigned int i; + int j; + int k; + const msurface_t *surface; + float normal[3]; + float v0[3]; + float v1[3]; + float edgedir[3]; + float edgenormal[3]; + float p[4]; + float midf; + float t1; + float t2; + VectorCopy(mid, p); + p[3] = 1; + surface = model->data_surfaces + node->firstsurface; + for (i = 0;i < node->numsurfaces;i++, surface++) + { + // skip surfaces whose bounding box does not include the point +// if (!BoxesOverlap(mid, mid, surface->mins, surface->maxs)) +// continue; + // skip faces with contents we don't care about + if (!(t->trace->hitsupercontentsmask & surface->texture->supercontents)) + continue; + // ignore surfaces matching the skipsupercontentsmask (this is rare) + if (t->trace->skipsupercontentsmask & surface->texture->supercontents) + continue; + // skip surfaces matching the skipmaterialflagsmask (e.g. MATERIALFLAG_NOSHADOW) + if (t->trace->skipmaterialflagsmask & surface->texture->currentmaterialflags) + continue; + // get the surface normal - since it is flat we know any vertex normal will suffice + VectorCopy(model->surfmesh.data_normal3f + 3 * surface->num_firstvertex, normal); + // skip backfaces + if (DotProduct(t->dist, normal) > 0) + continue; + // iterate edges and see if the point is outside one of them + for (j = 0, k = surface->num_vertices - 1;j < surface->num_vertices;k = j, j++) + { + VectorCopy(model->surfmesh.data_vertex3f + 3 * (surface->num_firstvertex + k), v0); + VectorCopy(model->surfmesh.data_vertex3f + 3 * (surface->num_firstvertex + j), v1); + VectorSubtract(v0, v1, edgedir); + CrossProduct(edgedir, normal, edgenormal); + if (DotProduct(edgenormal, p) > DotProduct(edgenormal, v0)) + break; } + // if the point is outside one of the edges, it is not within the surface + if (j < surface->num_vertices) + continue; + + // we hit a surface, this is the impact point... + VectorCopy(normal, t->trace->plane.normal); + t->trace->plane.dist = DotProduct(normal, p); + + // calculate the return fraction which is nudged off the surface a bit + t1 = DotProduct(t->start, t->trace->plane.normal) - t->trace->plane.dist; + t2 = DotProduct(t->end, t->trace->plane.normal) - t->trace->plane.dist; + midf = (t1 - collision_impactnudge.value) / (t1 - t2); + t->trace->fraction = bound(0, midf, 1); + + t->trace->hittexture = surface->texture->currentframe; + t->trace->hitq3surfaceflags = t->trace->hittexture->surfaceflags; + t->trace->hitsupercontents = t->trace->hittexture->supercontents; + return surface->texture->currentframe; } + return NULL; } -/* -============= -R_Q1BSP_LoadSplitSky - -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) +static int Mod_Q1BSP_TraceLineAgainstSurfacesRecursiveBSPNode(RecursiveHullCheckTraceInfo_t *t, const dp_model_t *model, const mnode_t *node, const double p1[3], const double p2[3]) { - int i, j; - unsigned solidpixels[128*128], alphapixels[128*128]; - - // allocate a texture pool if we need it - if (loadmodel->texturepool == NULL && cls.state != ca_dedicated) - loadmodel->texturepool = R_AllocTexturePool(); + const mplane_t *plane; + double t1, t2; + int side; + double midf, mid[3]; + const mleaf_t *leaf; - if (bytesperpixel == 4) + while (node->plane) { - for (i = 0;i < 128;i++) + plane = node->plane; + if (plane->type < 3) { - for (j = 0;j < 128;j++) - { - solidpixels[(i*128) + j] = ((unsigned *)src)[i*256+j+128]; - alphapixels[(i*128) + j] = ((unsigned *)src)[i*256+j]; - } + t1 = p1[plane->type] - plane->dist; + t2 = p2[plane->type] - plane->dist; } - } - else - { - // make an average value for the back to avoid - // a fringe on the top level - int p, r, g, b; - union + else { - unsigned int i; - unsigned char b[4]; + t1 = DotProduct (plane->normal, p1) - plane->dist; + t2 = DotProduct (plane->normal, p2) - plane->dist; } - bgra; - r = g = b = 0; - for (i = 0;i < 128;i++) + if (t1 < 0) { - for (j = 0;j < 128;j++) + if (t2 < 0) { - p = src[i*256 + j + 128]; - r += palette_rgb[p][0]; - g += palette_rgb[p][1]; - b += palette_rgb[p][2]; + node = node->children[1]; + continue; } + side = 1; } - bgra.b[2] = r/(128*128); - bgra.b[1] = g/(128*128); - bgra.b[0] = b/(128*128); - bgra.b[3] = 0; - for (i = 0;i < 128;i++) + else { - for (j = 0;j < 128;j++) + if (t2 >= 0) { - solidpixels[(i*128) + j] = palette_bgra_complete[src[i*256 + j + 128]]; - p = src[i*256 + j]; - alphapixels[(i*128) + j] = p ? palette_bgra_complete[p] : bgra.i; + node = node->children[0]; + continue; } + side = 0; } - } - loadmodel->brush.solidskytexture = R_LoadTexture2D(loadmodel->texturepool, "sky_solidtexture", 128, 128, (unsigned char *) solidpixels, TEXTYPE_BGRA, TEXF_PRECACHE, NULL); - loadmodel->brush.alphaskytexture = R_LoadTexture2D(loadmodel->texturepool, "sky_alphatexture", 128, 128, (unsigned char *) alphapixels, TEXTYPE_BGRA, TEXF_ALPHA | TEXF_PRECACHE, NULL); + // the line intersects, find intersection point + // LordHavoc: this uses the original trace for maximum accuracy + if (plane->type < 3) + { + t1 = t->start[plane->type] - plane->dist; + t2 = t->end[plane->type] - plane->dist; + } + else + { + t1 = DotProduct (plane->normal, t->start) - plane->dist; + t2 = DotProduct (plane->normal, t->end) - plane->dist; + } + + midf = t1 / (t1 - t2); + VectorMA(t->start, midf, t->dist, mid); + + // recurse both sides, front side first, return if we hit a surface + if (Mod_Q1BSP_TraceLineAgainstSurfacesRecursiveBSPNode(t, model, node->children[side], p1, mid) == HULLCHECKSTATE_DONE) + return HULLCHECKSTATE_DONE; + + // test each surface on the node + Mod_Q1BSP_TraceLineAgainstSurfacesFindTextureOnNode(t, model, node, mid); + if (t->trace->hittexture) + return HULLCHECKSTATE_DONE; + + // recurse back side + return Mod_Q1BSP_TraceLineAgainstSurfacesRecursiveBSPNode(t, model, node->children[side ^ 1], mid, p2); + } + leaf = (const mleaf_t *)node; + side = Mod_Q1BSP_SuperContentsFromNativeContents(leaf->contents); + if (!t->trace->startfound) + { + t->trace->startfound = true; + t->trace->startsupercontents |= side; + } + if (side & SUPERCONTENTS_LIQUIDSMASK) + t->trace->inwater = true; + if (side == 0) + t->trace->inopen = true; + if (side & t->trace->hitsupercontentsmask) + { + // if the first leaf is solid, set startsolid + if (t->trace->allsolid) + t->trace->startsolid = true; + return HULLCHECKSTATE_SOLID; + } + else + { + t->trace->allsolid = false; + return HULLCHECKSTATE_EMPTY; + } +} + +static void Mod_Q1BSP_TraceLineAgainstSurfaces(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, int skipsupercontentsmask, int skipmaterialflagsmask) +{ + RecursiveHullCheckTraceInfo_t rhc; + + memset(&rhc, 0, sizeof(rhc)); + memset(trace, 0, sizeof(trace_t)); + rhc.trace = trace; + rhc.trace->hitsupercontentsmask = hitsupercontentsmask; + rhc.trace->skipsupercontentsmask = skipsupercontentsmask; + rhc.trace->skipmaterialflagsmask = skipmaterialflagsmask; + rhc.trace->fraction = 1; + rhc.trace->allsolid = true; + rhc.hull = &model->brushq1.hulls[0]; // 0x0x0 + VectorCopy(start, rhc.start); + VectorCopy(end, rhc.end); + VectorSubtract(rhc.end, rhc.start, rhc.dist); + Mod_Q1BSP_TraceLineAgainstSurfacesRecursiveBSPNode(&rhc, model, model->brush.data_nodes + rhc.hull->firstclipnode, rhc.start, rhc.end); + VectorMA(rhc.start, rhc.trace->fraction, rhc.dist, rhc.trace->endpos); +} + +static void Mod_Q1BSP_DecompressVis(const unsigned char *in, const unsigned char *inend, unsigned char *out, unsigned char *outend) +{ + int c; + unsigned char *outstart = out; + while (out < outend) + { + if (in == inend) + { + Con_Printf("Mod_Q1BSP_DecompressVis: input underrun on model \"%s\" (decompressed %i of %i output bytes)\n", loadmodel->name, (int)(out - outstart), (int)(outend - outstart)); + return; + } + c = *in++; + if (c) + *out++ = c; + else + { + if (in == inend) + { + Con_Printf("Mod_Q1BSP_DecompressVis: input underrun (during zero-run) on model \"%s\" (decompressed %i of %i output bytes)\n", loadmodel->name, (int)(out - outstart), (int)(outend - outstart)); + return; + } + for (c = *in++;c > 0;c--) + { + if (out == outend) + { + Con_Printf("Mod_Q1BSP_DecompressVis: output overrun on model \"%s\" (decompressed %i of %i output bytes)\n", loadmodel->name, (int)(out - outstart), (int)(outend - outstart)); + return; + } + *out++ = 0; + } + } + } +} + +/* +============= +R_Q1BSP_LoadSplitSky + +A sky texture is 256*128, with the right side being a masked overlay +============== +*/ +static void R_Q1BSP_LoadSplitSky (unsigned char *src, int width, int height, int bytesperpixel) +{ + int x, y; + int w = width/2; + int h = height; + unsigned int *solidpixels = (unsigned int *)Mem_Alloc(tempmempool, w*h*sizeof(unsigned char[4])); + unsigned int *alphapixels = (unsigned int *)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 (bytesperpixel == 4) + { + for (y = 0;y < h;y++) + { + for (x = 0;x < w;x++) + { + solidpixels[y*w+x] = ((unsigned *)src)[y*width+x+w]; + alphapixels[y*w+x] = ((unsigned *)src)[y*width+x]; + } + } + } + else + { + // make an average value for the back to avoid + // a fringe on the top level + int p, r, g, b; + union + { + unsigned int i; + unsigned char b[4]; + } + bgra; + r = g = b = 0; + for (y = 0;y < h;y++) + { + for (x = 0;x < w;x++) + { + p = src[x*width+y+w]; + r += palette_rgb[p][0]; + g += palette_rgb[p][1]; + b += palette_rgb[p][2]; + } + } + 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 (x = 0;x < w;x++) + { + 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.solidskyskinframe = R_SkinFrame_LoadInternalBGRA("sky_solidtexture", 0 , (unsigned char *) solidpixels, w, h, 0, 0, 0, vid.sRGB3D); + loadmodel->brush.alphaskyskinframe = R_SkinFrame_LoadInternalBGRA("sky_alphatexture", TEXF_ALPHA, (unsigned char *) alphapixels, w, h, 0, 0, 0, vid.sRGB3D); + Mem_Free(solidpixels); + Mem_Free(alphapixels); } -static void Mod_Q1BSP_LoadTextures(lump_t *l) +static void Mod_Q1BSP_LoadTextures(sizebuf_t *sb) { - int i, j, k, num, max, altmax, mtwidth, mtheight, *dofs, incomplete; - skinframe_t *skinframe; - miptex_t *dmiptex; - texture_t *tx, *tx2, *anims[10], *altanims[10]; - dmiptexlump_t *m; + int i, j, k, num, max, altmax, mtwidth, mtheight, doffset, incomplete, nummiptex = 0, firstskynoshadowtexture = 0; + skinframe_t *skinframemissing; + texture_t *tx, *tx2, *anims[10], *altanims[10], *currentskynoshadowtexture; + texture_t backuptex; unsigned char *data, *mtdata; const char *s; char mapname[MAX_QPATH], name[MAX_QPATH]; - unsigned char zero[4]; - - memset(zero, 0, sizeof(zero)); + unsigned char zeroopaque[4], zerotrans[4]; + sizebuf_t miptexsb; + char vabuf[1024]; + Vector4Set(zeroopaque, 0, 0, 0, 255); + Vector4Set(zerotrans, 0, 0, 0, 128); loadmodel->data_textures = NULL; - // add two slots for notexture walls and notexture liquids - if (l->filelen) - { - m = (dmiptexlump_t *)(mod_base + l->fileofs); - m->nummiptex = LittleLong (m->nummiptex); - loadmodel->num_textures = m->nummiptex + 2; - loadmodel->num_texturesperskin = loadmodel->num_textures; + // add two slots for notexture walls and notexture liquids, and duplicate + // all sky textures; sky surfaces can be shadow-casting or not, the surface + // loading will choose according to the contents behind the surface + // (necessary to support e1m5 logo shadow which has a SKY contents brush, + // while correctly treating sky textures as occluders in other situations). + if (sb->cursize) + { + int numsky = 0; + size_t watermark; + nummiptex = MSG_ReadLittleLong(sb); + loadmodel->num_textures = nummiptex + 2; + // save the position so we can go back to it + watermark = sb->readcount; + for (i = 0; i < nummiptex; i++) + { + doffset = MSG_ReadLittleLong(sb); + if (r_nosurftextures.integer) + continue; + if (doffset == -1) + { + Con_DPrintf("%s: miptex #%i missing\n", loadmodel->name, i); + continue; + } + + MSG_InitReadBuffer(&miptexsb, sb->data + doffset, sb->cursize - doffset); + + // copy name, but only up to 16 characters + // (the output buffer can hold more than this, but the input buffer is + // only 16) + for (j = 0; j < 16; j++) + name[j] = MSG_ReadByte(&miptexsb); + name[j] = 0; + // pretty up the buffer (replacing any trailing garbage with 0) + for (j = (int)strlen(name); j < 16; j++) + name[j] = 0; + + if (!strncmp(name, "sky", 3)) + numsky++; + } + + // bump it back to where we started parsing + sb->readcount = watermark; + + firstskynoshadowtexture = loadmodel->num_textures; + loadmodel->num_textures += numsky; } else { - m = NULL; loadmodel->num_textures = 2; - loadmodel->num_texturesperskin = loadmodel->num_textures; + firstskynoshadowtexture = loadmodel->num_textures; } + loadmodel->num_texturesperskin = loadmodel->num_textures; loadmodel->data_textures = (texture_t *)Mem_Alloc(loadmodel->mempool, loadmodel->num_textures * sizeof(texture_t)); + // we'll be writing to these in parallel for sky textures + currentskynoshadowtexture = loadmodel->data_textures + firstskynoshadowtexture; + // fill out all slots with notexture - if (cls.state != ca_dedicated) - skinframe = R_SkinFrame_LoadMissing(); - else - skinframe = NULL; + skinframemissing = R_SkinFrame_LoadMissing(); for (i = 0, tx = loadmodel->data_textures;i < loadmodel->num_textures;i++, tx++) { strlcpy(tx->name, "NO TEXTURE FOUND", sizeof(tx->name)); tx->width = 16; tx->height = 16; - if (cls.state != ca_dedicated) - { - tx->numskinframes = 1; - tx->skinframerate = 1; - tx->skinframes[0] = skinframe; - tx->currentskinframe = tx->skinframes[0]; - } + tx->basealpha = 1.0f; + tx->materialshaderpass = tx->shaderpasses[0] = Mod_CreateShaderPass(loadmodel->mempool, skinframemissing); + tx->materialshaderpass->skinframes[0] = skinframemissing; + tx->currentskinframe = skinframemissing; tx->basematerialflags = MATERIALFLAG_WALL; if (i == loadmodel->num_textures - 1) { @@ -1513,9 +1750,17 @@ static void Mod_Q1BSP_LoadTextures(lump_t *l) tx->reflectfactor = 1; Vector4Set(tx->reflectcolor4f, 1, 1, 1, 1); tx->r_water_wateralpha = 1; + tx->offsetmapping = OFFSETMAPPING_DEFAULT; + tx->offsetscale = 1; + tx->offsetbias = 0; + tx->specularscalemod = 1; + tx->specularpowermod = 1; + tx->transparentsort = TRANSPARENTSORT_DISTANCE; + // WHEN ADDING DEFAULTS HERE, REMEMBER TO PUT DEFAULTS IN ALL LOADERS + // JUST GREP FOR "specularscalemod = 1". } - if (!m) + if (!sb->cursize) { Con_Printf("%s: no miptex lump to load textures from\n", loadmodel->name); return; @@ -1526,27 +1771,29 @@ static void Mod_Q1BSP_LoadTextures(lump_t *l) s += 5; FS_StripExtension(s, mapname, sizeof(mapname)); - // just to work around bounds checking when debugging with it (array index out of bounds error thing) - dofs = m->dataofs; // LordHavoc: mostly rewritten map texture loader - for (i = 0;i < m->nummiptex;i++) + for (i = 0;i < nummiptex;i++) { - dofs[i] = LittleLong(dofs[i]); + doffset = MSG_ReadLittleLong(sb); if (r_nosurftextures.integer) continue; - if (dofs[i] == -1) + if (doffset == -1) { Con_DPrintf("%s: miptex #%i missing\n", loadmodel->name, i); continue; } - dmiptex = (miptex_t *)((unsigned char *)m + dofs[i]); + + MSG_InitReadBuffer(&miptexsb, sb->data + doffset, sb->cursize - doffset); // copy name, but only up to 16 characters // (the output buffer can hold more than this, but the input buffer is // only 16) - for (j = 0;j < 16 && dmiptex->name[j];j++) - name[j] = dmiptex->name[j]; + for (j = 0;j < 16;j++) + name[j] = MSG_ReadByte(&miptexsb); name[j] = 0; + // pretty up the buffer (replacing any trailing garbage with 0) + for (j = (int)strlen(name);j < 16;j++) + name[j] = 0; if (!name[0]) { @@ -1554,36 +1801,44 @@ static void Mod_Q1BSP_LoadTextures(lump_t *l) Con_DPrintf("%s: warning: renaming unnamed texture to %s\n", loadmodel->name, name); } - mtwidth = LittleLong(dmiptex->width); - mtheight = LittleLong(dmiptex->height); + mtwidth = MSG_ReadLittleLong(&miptexsb); + mtheight = MSG_ReadLittleLong(&miptexsb); mtdata = NULL; - j = LittleLong(dmiptex->offsets[0]); + j = MSG_ReadLittleLong(&miptexsb); if (j) { // texture included - if (j < 40 || j + mtwidth * mtheight > l->filelen) + if (j < 40 || j + mtwidth * mtheight > miptexsb.cursize) { - Con_Printf("%s: Texture \"%s\" is corrupt or incomplete\n", loadmodel->name, dmiptex->name); + Con_Printf("%s: Texture \"%s\" is corrupt or incomplete\n", loadmodel->name, name); continue; } - mtdata = (unsigned char *)dmiptex + j; + mtdata = miptexsb.data + j; } if ((mtwidth & 15) || (mtheight & 15)) - Con_DPrintf("%s: warning: texture \"%s\" is not 16 aligned\n", loadmodel->name, dmiptex->name); + Con_DPrintf("%s: warning: texture \"%s\" is not 16 aligned\n", loadmodel->name, name); // LordHavoc: force all names to lowercase for (j = 0;name[j];j++) if (name[j] >= 'A' && name[j] <= 'Z') name[j] += 'a' - 'A'; - if (dmiptex->name[0] && Mod_LoadTextureFromQ3Shader(loadmodel->data_textures + i, name, false, false, 0)) + // LordHavoc: backup the texture_t because q3 shader loading overwrites it + backuptex = loadmodel->data_textures[i]; + if (name[0] && Mod_LoadTextureFromQ3Shader(loadmodel->mempool, loadmodel->name, loadmodel->data_textures + i, name, false, false, 0, MATERIALFLAG_WALL)) continue; + loadmodel->data_textures[i] = backuptex; tx = loadmodel->data_textures + i; strlcpy(tx->name, name, sizeof(tx->name)); tx->width = mtwidth; tx->height = mtheight; + tx->basealpha = 1.0f; + + // start out with no animation + tx->currentframe = tx; + tx->currentskinframe = tx->materialshaderpass != NULL ? tx->materialshaderpass->skinframes[0] : NULL; if (tx->name[0] == '*') { @@ -1607,6 +1862,8 @@ static void Mod_Q1BSP_LoadTextures(lump_t *l) { tx->supercontents = mod_q1bsp_texture_sky.supercontents; tx->surfaceflags = mod_q1bsp_texture_sky.surfaceflags; + // for the surface traceline we need to hit this surface as a solid... + tx->supercontents |= SUPERCONTENTS_SOLID; } else { @@ -1617,10 +1874,12 @@ 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) { - data = loadimagepixelsbgra(tx->name, false, false); - if (data && image_width == 256 && image_height == 128) + data = loadimagepixelsbgra(gamemode == GAME_TENEBRAE ? tx->name : va(vabuf, sizeof(vabuf), "textures/%s/%s", mapname, tx->name), false, false, false, NULL); + if (!data) + data = loadimagepixelsbgra(gamemode == GAME_TENEBRAE ? tx->name : va(vabuf, sizeof(vabuf), "textures/%s", tx->name), false, false, false, NULL); + if (data && image_width == image_height * 2) { R_Q1BSP_LoadSplitSky(data, image_width, image_height, 4); Mem_Free(data); @@ -1630,9 +1889,11 @@ static void Mod_Q1BSP_LoadTextures(lump_t *l) } else { - 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); + skinframe_t *skinframe = R_SkinFrame_LoadExternal(gamemode == GAME_TENEBRAE ? tx->name : va(vabuf, sizeof(vabuf), "textures/%s/%s", mapname, tx->name), TEXF_ALPHA | TEXF_MIPMAP | TEXF_ISWORLD | TEXF_PICMIP | TEXF_COMPRESS, false, false); if (!skinframe) - 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); + skinframe = R_SkinFrame_LoadExternal(gamemode == GAME_TENEBRAE ? tx->name : va(vabuf, sizeof(vabuf), "textures/%s", tx->name), TEXF_ALPHA | TEXF_MIPMAP | TEXF_ISWORLD | TEXF_PICMIP | TEXF_COMPRESS, false, false); + if (skinframe) + tx->offsetmapping = OFFSETMAPPING_DEFAULT; // allow offsetmapping on external textures without a q3 shader if (!skinframe) { // did not find external texture, load it from the bsp or wad3 @@ -1642,71 +1903,87 @@ static void Mod_Q1BSP_LoadTextures(lump_t *l) unsigned char *pixels, *freepixels; pixels = freepixels = NULL; if (mtdata) - pixels = W_ConvertWAD3TextureBGRA(dmiptex); + pixels = W_ConvertWAD3TextureBGRA(&miptexsb); if (pixels == NULL) pixels = freepixels = W_GetTextureBGRA(tx->name); if (pixels != NULL) { tx->width = image_width; tx->height = image_height; - skinframe = R_SkinFrame_LoadInternalBGRA(tx->name, TEXF_ALPHA | TEXF_MIPMAP | TEXF_PRECACHE | (r_picmipworld.integer ? TEXF_PICMIP : 0), pixels, image_width, image_height); + skinframe = R_SkinFrame_LoadInternalBGRA(tx->name, TEXF_ALPHA | TEXF_MIPMAP | TEXF_ISWORLD | TEXF_PICMIP, pixels, image_width, image_height, image_width, image_height, CRC_Block(pixels, image_width * image_height * 4), true); } if (freepixels) Mem_Free(freepixels); } else if (mtdata) // texture included - skinframe = R_SkinFrame_LoadInternalQuake(tx->name, TEXF_ALPHA | TEXF_MIPMAP | TEXF_PRECACHE | (r_picmipworld.integer ? TEXF_PICMIP : 0), false, r_fullbrights.integer, mtdata, tx->width, tx->height); + skinframe = R_SkinFrame_LoadInternalQuake(tx->name, TEXF_MIPMAP | TEXF_ISWORLD | TEXF_PICMIP, false, r_fullbrights.integer, mtdata, tx->width, tx->height); } - // if skinframe is still NULL the "missing" texture will be used + // if skinframe is still NULL the "missing" texture has already been assigned to this if (skinframe) - tx->skinframes[0] = skinframe; - } - - tx->basematerialflags = MATERIALFLAG_WALL; - if (tx->name[0] == '*') - { - // LordHavoc: some turbulent textures should not be affected by wateralpha - if (!strncmp(tx->name, "*glassmirror", 12)) // Tenebrae - { - // replace the texture with transparent black - Vector4Set(zero, 128, 128, 128, 128); - tx->skinframes[0] = R_SkinFrame_LoadInternalBGRA(tx->name, TEXF_MIPMAP | TEXF_PRECACHE | TEXF_ALPHA, zero, 1, 1); - tx->basematerialflags |= MATERIALFLAG_NOSHADOW | MATERIALFLAG_ADD | MATERIALFLAG_BLENDED | MATERIALFLAG_REFLECTION; - } - else if (!strncmp(tx->name,"*lava",5) - || !strncmp(tx->name,"*teleport",9) - || !strncmp(tx->name,"*rift",5)) // Scourge of Armagon texture - tx->basematerialflags |= MATERIALFLAG_WATERSCROLL | MATERIALFLAG_LIGHTBOTHSIDES | MATERIALFLAG_NOSHADOW; - else - tx->basematerialflags |= MATERIALFLAG_WATERSCROLL | MATERIALFLAG_LIGHTBOTHSIDES | MATERIALFLAG_NOSHADOW | MATERIALFLAG_WATERALPHA | MATERIALFLAG_WATERSHADER; - if (tx->skinframes[0] && tx->skinframes[0]->fog) - tx->basematerialflags |= MATERIALFLAG_ALPHA | MATERIALFLAG_BLENDED | MATERIALFLAG_NOSHADOW; + tx->materialshaderpass->skinframes[0] = skinframe; } + // LordHavoc: some Tenebrae textures get replaced by black + if (!strncmp(tx->name, "*glassmirror", 12)) // Tenebrae + tx->materialshaderpass->skinframes[0] = R_SkinFrame_LoadInternalBGRA(tx->name, TEXF_MIPMAP | TEXF_ALPHA, zerotrans, 1, 1, 0, 0, 0, false); 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 if (!strcmp(tx->name, "caulk")) - tx->basematerialflags = MATERIALFLAG_NODRAW | MATERIALFLAG_NOSHADOW; - else if (tx->skinframes[0] && tx->skinframes[0]->fog) + tx->materialshaderpass->skinframes[0] = R_SkinFrame_LoadInternalBGRA(tx->name, 0, zeroopaque, 1, 1, 0, 0, 0, false); + tx->currentskinframe = tx->materialshaderpass->skinframes[0]; + } + + tx->basematerialflags = MATERIALFLAG_WALL; + if (tx->name[0] == '*') + { + // LordHavoc: some turbulent textures should not be affected by wateralpha + if (!strncmp(tx->name, "*glassmirror", 12)) // Tenebrae + 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->currentskinframe != NULL && tx->currentskinframe->hasalpha) tx->basematerialflags |= MATERIALFLAG_ALPHA | MATERIALFLAG_BLENDED | MATERIALFLAG_NOSHADOW; + } + else if (tx->name[0] == '{') // fence textures + { + tx->basematerialflags |= MATERIALFLAG_ALPHATEST | MATERIALFLAG_NOSHADOW; + } + else if (!strncmp(tx->name, "mirror", 6)) // Tenebrae + { + // replace the texture with black + tx->basematerialflags |= MATERIALFLAG_REFLECTION; + } + else if (!strncmp(tx->name, "sky", 3)) + tx->basematerialflags = MATERIALFLAG_SKY; + else if (!strcmp(tx->name, "caulk")) + tx->basematerialflags = MATERIALFLAG_NODRAW | MATERIALFLAG_NOSHADOW; + else if (tx->currentskinframe != NULL && tx->currentskinframe->hasalpha) + tx->basematerialflags |= MATERIALFLAG_ALPHA | MATERIALFLAG_BLENDED | MATERIALFLAG_NOSHADOW; + tx->currentmaterialflags = tx->basematerialflags; - // start out with no animation - tx->currentframe = tx; - tx->currentskinframe = tx->skinframes[0]; + // duplicate of sky with NOSHADOW + if (tx->basematerialflags & MATERIALFLAG_SKY) + { + *currentskynoshadowtexture = *tx; + currentskynoshadowtexture->basematerialflags |= MATERIALFLAG_NOSHADOW; + tx->skynoshadowtexture = currentskynoshadowtexture; + currentskynoshadowtexture++; } } // sequence the animations - for (i = 0;i < m->nummiptex;i++) + for (i = 0;i < nummiptex;i++) { tx = loadmodel->data_textures + i; if (!tx || tx->name[0] != '+' || tx->name[1] == 0 || tx->name[2] == 0) continue; + num = tx->name[1]; + if ((num < '0' || num > '9') && (num < 'a' || num > 'j')) + { + Con_Printf("Bad animating texture %s\n", tx->name); + continue; + } if (tx->anim_total[0] || tx->anim_total[1]) continue; // already sequenced @@ -1714,7 +1991,7 @@ static void Mod_Q1BSP_LoadTextures(lump_t *l) memset(anims, 0, sizeof(anims)); memset(altanims, 0, sizeof(altanims)); - for (j = i;j < m->nummiptex;j++) + for (j = i;j < nummiptex;j++) { tx2 = loadmodel->data_textures + j; if (!tx2 || tx2->name[0] != '+' || strcmp(tx2->name+2, tx->name+2)) @@ -1725,8 +2002,7 @@ static void Mod_Q1BSP_LoadTextures(lump_t *l) anims[num - '0'] = tx2; else if (num >= 'a' && num <= 'j') altanims[num - 'a'] = tx2; - else - Con_Printf("Bad animating texture %s\n", tx->name); + // No need to warn otherwise - we already did above. } max = altmax = 0; @@ -1759,6 +2035,12 @@ static void Mod_Q1BSP_LoadTextures(lump_t *l) if (incomplete) continue; + // If we have exactly one frame, something's wrong. + if (max + altmax <= 1) + { + Con_Printf("Texture %s is animated (leading +) but has only one frame\n", tx->name); + } + if (altmax < 1) { // if there is no alternate animation, duplicate the primary @@ -1768,11 +2050,23 @@ static void Mod_Q1BSP_LoadTextures(lump_t *l) altanims[k] = anims[k]; } + if (max < 1) + { + // Warn. + Con_Printf("Missing frame 0 of %s\n", tx->name); + + // however, we can handle this by duplicating the alternate animation into the primary + max = altmax; + for (k = 0;k < 10;k++) + anims[k] = altanims[k]; + } + + // link together the primary animation for (j = 0;j < max;j++) { tx2 = anims[j]; - tx2->animated = true; + tx2->animated = 1; // q1bsp tx2->anim_total[0] = max; tx2->anim_total[1] = altmax; for (k = 0;k < 10;k++) @@ -1789,7 +2083,7 @@ static void Mod_Q1BSP_LoadTextures(lump_t *l) for (j = 0;j < altmax;j++) { tx2 = altanims[j]; - tx2->animated = true; + tx2->animated = 1; // q1bsp // the primary/alternate are reversed here tx2->anim_total[0] = altmax; tx2->anim_total[1] = max; @@ -1803,7 +2097,7 @@ static void Mod_Q1BSP_LoadTextures(lump_t *l) } } -static void Mod_Q1BSP_LoadLighting(lump_t *l) +static void Mod_Q1BSP_LoadLighting(sizebuf_t *sb) { int i; unsigned char *in, *out, *data, d; @@ -1812,9 +2106,9 @@ static void Mod_Q1BSP_LoadLighting(lump_t *l) fs_offset_t filesize; if (loadmodel->brush.ishlbsp) // LordHavoc: load the colored lighting data straight { - loadmodel->brushq1.lightdata = (unsigned char *)Mem_Alloc(loadmodel->mempool, l->filelen); - for (i=0; ifilelen; i++) - loadmodel->brushq1.lightdata[i] = mod_base[l->fileofs+i] >>= 1; + loadmodel->brushq1.lightdata = (unsigned char *)Mem_Alloc(loadmodel->mempool, sb->cursize); + for (i = 0;i < sb->cursize;i++) + loadmodel->brushq1.lightdata[i] = sb->data[i] >>= 1; } else // LordHavoc: bsp version 29 (normal white lighting) { @@ -1827,7 +2121,7 @@ static void Mod_Q1BSP_LoadLighting(lump_t *l) data = (unsigned char*) FS_LoadFile(litfilename, tempmempool, false, &filesize); if (data) { - if (filesize == (fs_offset_t)(8 + l->filelen * 3) && data[0] == 'Q' && data[1] == 'L' && data[2] == 'I' && data[3] == 'T') + if (filesize == (fs_offset_t)(8 + sb->cursize * 3) && data[0] == 'Q' && data[1] == 'L' && data[2] == 'I' && data[3] == 'T') { i = LittleLong(((int *)data)[1]); if (i == 1) @@ -1840,7 +2134,7 @@ static void Mod_Q1BSP_LoadLighting(lump_t *l) data = (unsigned char*) FS_LoadFile(dlitfilename, tempmempool, false, &filesize); if (data) { - if (filesize == (fs_offset_t)(8 + l->filelen * 3) && data[0] == 'Q' && data[1] == 'L' && data[2] == 'I' && data[3] == 'T') + if (filesize == (fs_offset_t)(8 + sb->cursize * 3) && data[0] == 'Q' && data[1] == 'L' && data[2] == 'I' && data[3] == 'T') { i = LittleLong(((int *)data)[1]); if (i == 1) @@ -1864,7 +2158,7 @@ static void Mod_Q1BSP_LoadLighting(lump_t *l) else if (filesize == 8) Con_Print("Empty .lit file, ignoring\n"); else - Con_Printf("Corrupt .lit file (file size %i bytes, should be %i bytes), ignoring\n", (int) filesize, (int) (8 + l->filelen * 3)); + Con_Printf("Corrupt .lit file (file size %i bytes, should be %i bytes), ignoring\n", (int) filesize, (int) (8 + sb->cursize * 3)); if (data) { Mem_Free(data); @@ -1872,12 +2166,12 @@ static void Mod_Q1BSP_LoadLighting(lump_t *l) } } // LordHavoc: oh well, expand the white lighting data - if (!l->filelen) + if (!sb->cursize) return; - loadmodel->brushq1.lightdata = (unsigned char *)Mem_Alloc(loadmodel->mempool, l->filelen*3); - in = mod_base + l->fileofs; + loadmodel->brushq1.lightdata = (unsigned char *)Mem_Alloc(loadmodel->mempool, sb->cursize*3); + in = sb->data; out = loadmodel->brushq1.lightdata; - for (i = 0;i < l->filelen;i++) + for (i = 0;i < sb->cursize;i++) { d = *in++; *out++ = d; @@ -1887,15 +2181,15 @@ static void Mod_Q1BSP_LoadLighting(lump_t *l) } } -static void Mod_Q1BSP_LoadVisibility(lump_t *l) +static void Mod_Q1BSP_LoadVisibility(sizebuf_t *sb) { loadmodel->brushq1.num_compressedpvs = 0; loadmodel->brushq1.data_compressedpvs = NULL; - if (!l->filelen) + if (!sb->cursize) return; - loadmodel->brushq1.num_compressedpvs = l->filelen; - loadmodel->brushq1.data_compressedpvs = (unsigned char *)Mem_Alloc(loadmodel->mempool, l->filelen); - memcpy(loadmodel->brushq1.data_compressedpvs, mod_base + l->fileofs, l->filelen); + loadmodel->brushq1.num_compressedpvs = sb->cursize; + loadmodel->brushq1.data_compressedpvs = (unsigned char *)Mem_Alloc(loadmodel->mempool, sb->cursize); + MSG_ReadBytes(sb, sb->cursize, loadmodel->brushq1.data_compressedpvs); } // used only for HalfLife maps @@ -1905,13 +2199,13 @@ static void Mod_Q1BSP_ParseWadsFromEntityLump(const char *data) int i, j, k; if (!data) return; - if (!COM_ParseToken_Simple(&data, false, false)) + if (!COM_ParseToken_Simple(&data, false, false, true)) return; // error if (com_token[0] != '{') return; // error while (1) { - if (!COM_ParseToken_Simple(&data, false, false)) + if (!COM_ParseToken_Simple(&data, false, false, true)) return; // error if (com_token[0] == '}') break; // end of worldspawn @@ -1921,7 +2215,7 @@ static void Mod_Q1BSP_ParseWadsFromEntityLump(const char *data) strlcpy(key, com_token, sizeof(key)); while (key[strlen(key)-1] == ' ') // remove trailing spaces key[strlen(key)-1] = 0; - if (!COM_ParseToken_Simple(&data, false, false)) + if (!COM_ParseToken_Simple(&data, false, false, true)) return; // error dpsnprintf(value, sizeof(value), "%s", com_token); if (!strcmp("wad", key)) // for HalfLife maps @@ -1932,7 +2226,7 @@ static void Mod_Q1BSP_ParseWadsFromEntityLump(const char *data) for (i = 0;i < (int)sizeof(value);i++) if (value[i] != ';' && value[i] != '\\' && value[i] != '/' && value[i] != ':') break; - if (value[i]) + if (i < (int)sizeof(value) && value[i]) { for (;i < (int)sizeof(value);i++) { @@ -1955,78 +2249,52 @@ static void Mod_Q1BSP_ParseWadsFromEntityLump(const char *data) } } -static void Mod_Q1BSP_LoadEntities(lump_t *l) +static void Mod_Q1BSP_LoadEntities(sizebuf_t *sb) { loadmodel->brush.entities = NULL; - if (!l->filelen) + if (!sb->cursize) return; - 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; + loadmodel->brush.entities = (char *)Mem_Alloc(loadmodel->mempool, sb->cursize + 1); + MSG_ReadBytes(sb, sb->cursize, (unsigned char *)loadmodel->brush.entities); + loadmodel->brush.entities[sb->cursize] = 0; if (loadmodel->brush.ishlbsp) Mod_Q1BSP_ParseWadsFromEntityLump(loadmodel->brush.entities); } -static void Mod_Q1BSP_LoadVertexes(lump_t *l) +static void Mod_Q1BSP_LoadVertexes(sizebuf_t *sb) { - dvertex_t *in; mvertex_t *out; int i, count; + int structsize = 12; - in = (dvertex_t *)(mod_base + l->fileofs); - if (l->filelen % sizeof(*in)) + if (sb->cursize % structsize) Host_Error("Mod_Q1BSP_LoadVertexes: funny lump size in %s",loadmodel->name); - count = l->filelen / sizeof(*in); + count = sb->cursize / structsize; out = (mvertex_t *)Mem_Alloc(loadmodel->mempool, count*sizeof(*out)); loadmodel->brushq1.vertexes = out; loadmodel->brushq1.numvertexes = count; - for ( i=0 ; iposition[0] = LittleFloat(in->point[0]); - out->position[1] = LittleFloat(in->point[1]); - out->position[2] = LittleFloat(in->point[2]); + out->position[0] = MSG_ReadLittleFloat(sb); + out->position[1] = MSG_ReadLittleFloat(sb); + out->position[2] = MSG_ReadLittleFloat(sb); } } -// The following two functions should be removed and MSG_* or SZ_* function sets adjusted so they -// can be used for this -// REMOVEME -int SB_ReadInt (unsigned char **buffer) -{ - int i; - i = ((*buffer)[0]) + 256*((*buffer)[1]) + 65536*((*buffer)[2]) + 16777216*((*buffer)[3]); - (*buffer) += 4; - return i; -} - -// REMOVEME -float SB_ReadFloat (unsigned char **buffer) -{ - union - { - int i; - float f; - } u; - - u.i = SB_ReadInt (buffer); - return u.f; -} - -static void Mod_Q1BSP_LoadSubmodels(lump_t *l, hullinfo_t *hullinfo) +static void Mod_Q1BSP_LoadSubmodels(sizebuf_t *sb, hullinfo_t *hullinfo) { - unsigned char *index; - dmodel_t *out; + mmodel_t *out; int i, j, count; + int structsize = (48+4*hullinfo->filehulls); - index = (unsigned char *)(mod_base + l->fileofs); - if (l->filelen % (48+4*hullinfo->filehulls)) + if (sb->cursize % structsize) Host_Error ("Mod_Q1BSP_LoadSubmodels: funny lump size in %s", loadmodel->name); - count = l->filelen / (48+4*hullinfo->filehulls); - out = (dmodel_t *)Mem_Alloc (loadmodel->mempool, count*sizeof(*out)); + count = sb->cursize / structsize; + out = (mmodel_t *)Mem_Alloc (loadmodel->mempool, count*sizeof(*out)); loadmodel->brushq1.submodels = out; loadmodel->brush.numsubmodels = count; @@ -2034,43 +2302,50 @@ static void Mod_Q1BSP_LoadSubmodels(lump_t *l, hullinfo_t *hullinfo) for (i = 0; i < count; i++, out++) { // spread out the mins / maxs by a pixel - out->mins[0] = SB_ReadFloat (&index) - 1; - out->mins[1] = SB_ReadFloat (&index) - 1; - out->mins[2] = SB_ReadFloat (&index) - 1; - out->maxs[0] = SB_ReadFloat (&index) + 1; - out->maxs[1] = SB_ReadFloat (&index) + 1; - out->maxs[2] = SB_ReadFloat (&index) + 1; - out->origin[0] = SB_ReadFloat (&index); - out->origin[1] = SB_ReadFloat (&index); - out->origin[2] = SB_ReadFloat (&index); + out->mins[0] = MSG_ReadLittleFloat(sb) - 1; + out->mins[1] = MSG_ReadLittleFloat(sb) - 1; + out->mins[2] = MSG_ReadLittleFloat(sb) - 1; + out->maxs[0] = MSG_ReadLittleFloat(sb) + 1; + out->maxs[1] = MSG_ReadLittleFloat(sb) + 1; + out->maxs[2] = MSG_ReadLittleFloat(sb) + 1; + out->origin[0] = MSG_ReadLittleFloat(sb); + out->origin[1] = MSG_ReadLittleFloat(sb); + out->origin[2] = MSG_ReadLittleFloat(sb); for (j = 0; j < hullinfo->filehulls; j++) - out->headnode[j] = SB_ReadInt (&index); - out->visleafs = SB_ReadInt (&index); - out->firstface = SB_ReadInt (&index); - out->numfaces = SB_ReadInt (&index); + out->headnode[j] = MSG_ReadLittleLong(sb); + out->visleafs = MSG_ReadLittleLong(sb); + out->firstface = MSG_ReadLittleLong(sb); + out->numfaces = MSG_ReadLittleLong(sb); } } -static void Mod_Q1BSP_LoadEdges(lump_t *l) +static void Mod_Q1BSP_LoadEdges(sizebuf_t *sb) { - dedge_t *in; medge_t *out; int i, count; + int structsize = loadmodel->brush.isbsp2 ? 8 : 4; - in = (dedge_t *)(mod_base + l->fileofs); - if (l->filelen % sizeof(*in)) + if (sb->cursize % structsize) Host_Error("Mod_Q1BSP_LoadEdges: funny lump size in %s",loadmodel->name); - count = l->filelen / sizeof(*in); + count = sb->cursize / structsize; out = (medge_t *)Mem_Alloc(loadmodel->mempool, count * sizeof(*out)); loadmodel->brushq1.edges = out; loadmodel->brushq1.numedges = count; - for ( i=0 ; iv[0] = (unsigned short)LittleShort(in->v[0]); - out->v[1] = (unsigned short)LittleShort(in->v[1]); - if (out->v[0] >= loadmodel->brushq1.numvertexes || out->v[1] >= loadmodel->brushq1.numvertexes) + if (loadmodel->brush.isbsp2) + { + out->v[0] = (unsigned int)MSG_ReadLittleLong(sb); + out->v[1] = (unsigned int)MSG_ReadLittleLong(sb); + } + else + { + out->v[0] = (unsigned short)MSG_ReadLittleShort(sb); + out->v[1] = (unsigned short)MSG_ReadLittleShort(sb); + } + if ((int)out->v[0] >= loadmodel->brushq1.numvertexes || (int)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) @@ -2082,50 +2357,47 @@ static void Mod_Q1BSP_LoadEdges(lump_t *l) } } -static void Mod_Q1BSP_LoadTexinfo(lump_t *l) +static void Mod_Q1BSP_LoadTexinfo(sizebuf_t *sb) { - texinfo_t *in; mtexinfo_t *out; int i, j, k, count, miptex; + int structsize = 40; - in = (texinfo_t *)(mod_base + l->fileofs); - if (l->filelen % sizeof(*in)) + if (sb->cursize % structsize) Host_Error("Mod_Q1BSP_LoadTexinfo: funny lump size in %s",loadmodel->name); - count = l->filelen / sizeof(*in); + count = sb->cursize / structsize; out = (mtexinfo_t *)Mem_Alloc(loadmodel->mempool, count * sizeof(*out)); loadmodel->brushq1.texinfo = out; loadmodel->brushq1.numtexinfo = count; - for (i = 0;i < count;i++, in++, out++) + for (i = 0;i < count;i++, out++) { for (k = 0;k < 2;k++) for (j = 0;j < 4;j++) - out->vecs[k][j] = LittleFloat(in->vecs[k][j]); + out->vecs[k][j] = MSG_ReadLittleFloat(sb); - miptex = LittleLong(in->miptex); - out->flags = LittleLong(in->flags); + miptex = MSG_ReadLittleLong(sb); + out->q1flags = MSG_ReadLittleLong(sb); - out->texture = NULL; - if (loadmodel->data_textures) - { - if ((unsigned int) miptex >= (unsigned int) loadmodel->num_textures) - Con_Printf("error in model \"%s\": invalid miptex index %i(of %i)\n", loadmodel->name, miptex, loadmodel->num_textures); - else - out->texture = loadmodel->data_textures + miptex; - } - if (out->flags & TEX_SPECIAL) + if (out->q1flags & TEX_SPECIAL) { // if texture chosen is NULL or the shader needs a lightmap, // force to notexture water shader - if (out->texture == NULL) - out->texture = loadmodel->data_textures + (loadmodel->num_textures - 1); + out->textureindex = loadmodel->num_textures - 1; } else { // if texture chosen is NULL, force to notexture - if (out->texture == NULL) - out->texture = loadmodel->data_textures + (loadmodel->num_textures - 2); + out->textureindex = loadmodel->num_textures - 2; + } + // see if the specified miptex is valid and try to use it instead + if (loadmodel->data_textures) + { + if ((unsigned int) miptex >= (unsigned int) loadmodel->num_textures) + Con_Printf("error in model \"%s\": invalid miptex index %i(of %i)\n", loadmodel->name, miptex, loadmodel->num_textures); + else + out->textureindex = miptex; } } } @@ -2282,128 +2554,77 @@ static void Mod_Q1BSP_GenerateWarpMesh(msurface_t *surface) } #endif -/* Maximum size of a single LM */ -#define MAX_SINGLE_LM_SIZE 256 - -struct alloc_lm_row -{ - int rowY; - int currentX; -}; - -struct alloc_lm_state -{ - int currentY; - struct alloc_lm_row rows[MAX_SINGLE_LM_SIZE]; -}; - -static void init_alloc_lm_state (struct alloc_lm_state* state) -{ - int r; - - state->currentY = 0; - for (r = 0; r < MAX_SINGLE_LM_SIZE; r++) - { - state->rows[r].currentX = 0; - state->rows[r].rowY = -1; - } -} - -static qboolean Mod_Q1BSP_AllocLightmapBlock(struct alloc_lm_state* state, int totalwidth, int totalheight, int blockwidth, int blockheight, int *outx, int *outy) -{ - struct alloc_lm_row* row; - int r; - - row = &(state->rows[blockheight]); - if ((row->rowY < 0) || (row->currentX + blockwidth > totalwidth)) - { - if (state->currentY + blockheight <= totalheight) - { - row->rowY = state->currentY; - row->currentX = 0; - state->currentY += blockheight; - } - else - { - /* See if we can stuff the block into a higher row */ - row = NULL; - for (r = blockheight; r < MAX_SINGLE_LM_SIZE; r++) - { - if ((state->rows[r].rowY >= 0) - && (state->rows[r].currentX + blockwidth <= totalwidth)) - { - row = &(state->rows[r]); - break; - } - } - if (row == NULL) return false; - } - } - *outy = row->rowY; - *outx = row->currentX; - row->currentX += blockwidth; - - return true; -} - -extern cvar_t gl_max_size; -static void Mod_Q1BSP_LoadFaces(lump_t *l) +extern cvar_t gl_max_lightmapsize; +static void Mod_Q1BSP_LoadFaces(sizebuf_t *sb) { - dface_t *in; msurface_t *surface; - int i, j, count, surfacenum, planenum, smax, tmax, ssize, tsize, firstedge, numedges, totalverts, totaltris, lightmapnumber, lightmapsize, totallightmapsamples; + int i, j, count, surfacenum, planenum, smax, tmax, ssize, tsize, firstedge, numedges, totalverts, totaltris, lightmapnumber, lightmapsize, totallightmapsamples, lightmapoffset, texinfoindex; float texmins[2], texmaxs[2], val; rtexture_t *lightmaptexture, *deluxemaptexture; + char vabuf[1024]; + int structsize = loadmodel->brush.isbsp2 ? 28 : 20; - in = (dface_t *)(mod_base + l->fileofs); - if (l->filelen % sizeof(*in)) + if (sb->cursize % structsize) Host_Error("Mod_Q1BSP_LoadFaces: funny lump size in %s",loadmodel->name); - count = l->filelen / sizeof(*in); + count = sb->cursize / structsize; loadmodel->data_surfaces = (msurface_t *)Mem_Alloc(loadmodel->mempool, count*sizeof(msurface_t)); loadmodel->data_surfaces_lightmapinfo = (msurface_lightmapinfo_t *)Mem_Alloc(loadmodel->mempool, count*sizeof(msurface_lightmapinfo_t)); loadmodel->num_surfaces = count; + loadmodel->brushq1.firstrender = true; 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++) + for (surfacenum = 0;surfacenum < count;surfacenum++) { - numedges = (unsigned short)LittleShort(in->numedges); + if (loadmodel->brush.isbsp2) + numedges = BuffLittleLong(sb->data + structsize * surfacenum + 12); + else + numedges = BuffLittleShort(sb->data + structsize * surfacenum + 8); totalverts += numedges; totaltris += numedges - 2; } - Mod_AllocSurfMesh(loadmodel->mempool, totalverts, totaltris, true, false, false); + Mod_AllocSurfMesh(loadmodel->mempool, totalverts, totaltris, true, false); lightmaptexture = NULL; deluxemaptexture = r_texture_blanknormalmap; - lightmapnumber = 1; - lightmapsize = max(256, gl_max_size.integer); + lightmapnumber = 0; + lightmapsize = bound(256, gl_max_lightmapsize.integer, (int)vid.maxtexturesize_2d); totallightmapsamples = 0; totalverts = 0; totaltris = 0; - for (surfacenum = 0, in = (dface_t *)(mod_base + l->fileofs), surface = loadmodel->data_surfaces;surfacenum < count;surfacenum++, in++, surface++) + for (surfacenum = 0, surface = loadmodel->data_surfaces;surfacenum < count;surfacenum++, surface++) { surface->lightmapinfo = loadmodel->data_surfaces_lightmapinfo + surfacenum; + // the struct on disk is the same in BSP29 (Q1), BSP30 (HL1), and IBSP38 (Q2) + planenum = loadmodel->brush.isbsp2 ? MSG_ReadLittleLong(sb) : (unsigned short)MSG_ReadLittleShort(sb); + /*side = */loadmodel->brush.isbsp2 ? MSG_ReadLittleLong(sb) : (unsigned short)MSG_ReadLittleShort(sb); + firstedge = MSG_ReadLittleLong(sb); + numedges = loadmodel->brush.isbsp2 ? MSG_ReadLittleLong(sb) : (unsigned short)MSG_ReadLittleShort(sb); + texinfoindex = loadmodel->brush.isbsp2 ? MSG_ReadLittleLong(sb) : (unsigned short)MSG_ReadLittleShort(sb); + for (i = 0;i < MAXLIGHTMAPS;i++) + surface->lightmapinfo->styles[i] = MSG_ReadByte(sb); + lightmapoffset = MSG_ReadLittleLong(sb); // FIXME: validate edges, texinfo, etc? - firstedge = LittleLong(in->firstedge); - numedges = (unsigned short)LittleShort(in->numedges); if ((unsigned int) firstedge > (unsigned int) loadmodel->brushq1.numsurfedges || (unsigned int) numedges > (unsigned int) loadmodel->brushq1.numsurfedges || (unsigned int) firstedge + (unsigned int) numedges > (unsigned int) loadmodel->brushq1.numsurfedges) Host_Error("Mod_Q1BSP_LoadFaces: invalid edge range (firstedge %i, numedges %i, model edges %i)", firstedge, numedges, loadmodel->brushq1.numsurfedges); - i = (unsigned short)LittleShort(in->texinfo); - if ((unsigned int) i >= (unsigned int) loadmodel->brushq1.numtexinfo) - Host_Error("Mod_Q1BSP_LoadFaces: invalid texinfo index %i(model has %i texinfos)", i, loadmodel->brushq1.numtexinfo); - surface->lightmapinfo->texinfo = loadmodel->brushq1.texinfo + i; - surface->texture = surface->lightmapinfo->texinfo->texture; - - planenum = (unsigned short)LittleShort(in->planenum); + if ((unsigned int) texinfoindex >= (unsigned int) loadmodel->brushq1.numtexinfo) + Host_Error("Mod_Q1BSP_LoadFaces: invalid texinfo index %i(model has %i texinfos)", texinfoindex, loadmodel->brushq1.numtexinfo); if ((unsigned int) planenum >= (unsigned int) loadmodel->brush.num_planes) Host_Error("Mod_Q1BSP_LoadFaces: invalid plane index %i (model has %i planes)", planenum, loadmodel->brush.num_planes); + surface->lightmapinfo->texinfo = loadmodel->brushq1.texinfo + texinfoindex; + surface->texture = loadmodel->data_textures + surface->lightmapinfo->texinfo->textureindex; + + // Q2BSP doesn't use lightmaps on sky or warped surfaces (water), but still has a lightofs of 0 + if (lightmapoffset == 0 && (surface->texture->q2flags & (Q2SURF_SKY | Q2SURF_WARP))) + lightmapoffset = -1; + //surface->flags = surface->texture->flags; //if (LittleShort(in->side)) // surface->flags |= SURF_PLANEBACK; @@ -2443,8 +2664,8 @@ static void Mod_Q1BSP_LoadFaces(lump_t *l) } // compile additional data about the surface geometry - Mod_BuildNormals(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, loadmodel->surfmesh.data_vertex3f, (loadmodel->surfmesh.data_element3i + 3 * surface->num_firsttriangle), loadmodel->surfmesh.data_normal3f, true); - Mod_BuildTextureVectorsFromNormals(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, loadmodel->surfmesh.data_vertex3f, loadmodel->surfmesh.data_texcoordtexture2f, loadmodel->surfmesh.data_normal3f, (loadmodel->surfmesh.data_element3i + 3 * surface->num_firsttriangle), loadmodel->surfmesh.data_svector3f, loadmodel->surfmesh.data_tvector3f, true); + Mod_BuildNormals(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, loadmodel->surfmesh.data_vertex3f, (loadmodel->surfmesh.data_element3i + 3 * surface->num_firsttriangle), loadmodel->surfmesh.data_normal3f, r_smoothnormals_areaweighting.integer != 0); + Mod_BuildTextureVectorsFromNormals(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, loadmodel->surfmesh.data_vertex3f, loadmodel->surfmesh.data_texcoordtexture2f, loadmodel->surfmesh.data_normal3f, (loadmodel->surfmesh.data_element3i + 3 * surface->num_firsttriangle), loadmodel->surfmesh.data_svector3f, loadmodel->surfmesh.data_tvector3f, r_smoothnormals_areaweighting.integer != 0); BoxFromPoints(surface->mins, surface->maxs, surface->num_vertices, (loadmodel->surfmesh.data_vertex3f + 3 * surface->num_firstvertex)); // generate surface extents information @@ -2471,17 +2692,14 @@ static void Mod_Q1BSP_LoadFaces(lump_t *l) tsize = (surface->lightmapinfo->extents[1] >> 4) + 1; // lighting info - for (i = 0;i < MAXLIGHTMAPS;i++) - surface->lightmapinfo->styles[i] = in->styles[i]; surface->lightmaptexture = NULL; surface->deluxemaptexture = r_texture_blanknormalmap; - i = LittleLong(in->lightofs); - if (i == -1) + if (lightmapoffset == -1) { surface->lightmapinfo->samples = NULL; -#if 0 +#if 1 // give non-lightmapped water a 1x white lightmap - if (surface->texture->name[0] == '*' && (surface->lightmapinfo->texinfo->flags & TEX_SPECIAL) && ssize <= 256 && tsize <= 256) + if (!loadmodel->brush.isq2bsp && surface->texture->name[0] == '*' && (surface->lightmapinfo->texinfo->q1flags & TEX_SPECIAL) && ssize <= 256 && tsize <= 256) { surface->lightmapinfo->samples = (unsigned char *)Mem_Alloc(loadmodel->mempool, ssize * tsize * 3); surface->lightmapinfo->styles[0] = 0; @@ -2489,17 +2707,17 @@ static void Mod_Q1BSP_LoadFaces(lump_t *l) } #endif } - else if (loadmodel->brush.ishlbsp) // LordHavoc: HalfLife map (bsp version 30) - surface->lightmapinfo->samples = loadmodel->brushq1.lightdata + i; + else if (loadmodel->brush.ishlbsp || loadmodel->brush.isq2bsp) // LordHavoc: HalfLife map (bsp version 30) + surface->lightmapinfo->samples = loadmodel->brushq1.lightdata + lightmapoffset; else // LordHavoc: white lighting (bsp version 29) { - surface->lightmapinfo->samples = loadmodel->brushq1.lightdata + (i * 3); + surface->lightmapinfo->samples = loadmodel->brushq1.lightdata + (lightmapoffset * 3); if (loadmodel->brushq1.nmaplightdata) - surface->lightmapinfo->nmapsamples = loadmodel->brushq1.nmaplightdata + (i * 3); + surface->lightmapinfo->nmapsamples = loadmodel->brushq1.nmaplightdata + (lightmapoffset * 3); } // check if we should apply a lightmap to this - if (!(surface->lightmapinfo->texinfo->flags & TEX_SPECIAL) || surface->lightmapinfo->samples) + if (!(surface->lightmapinfo->texinfo->q1flags & TEX_SPECIAL) || surface->lightmapinfo->samples) { if (ssize > 256 || tsize > 256) Host_Error("Bad surface extents"); @@ -2517,29 +2735,30 @@ static void Mod_Q1BSP_LoadFaces(lump_t *l) // lightmap is needed on this surface (rather than duplicating the // logic above) loadmodel->brushq1.lightmapupdateflags[surfacenum] = true; + loadmodel->lit = 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) i = lightmapsize; - for (lightmapsize = 64; (lightmapsize < i) && (lightmapsize < gl_max_size.integer) && (totallightmapsamples > 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; - struct alloc_lm_state allocState; + mod_alloclightmap_state_t allocState; + Mod_AllocLightmap_Init(&allocState, loadmodel->mempool, lightmapsize, lightmapsize); for (surfacenum = 0, surface = loadmodel->data_surfaces;surfacenum < count;surfacenum++, surface++) { - int i, iu, iv, lightmapx = 0, lightmapy = 0; + int iu, iv, lightmapx = 0, lightmapy = 0; float u, v, ubase, vbase, uscale, vscale; if (!loadmodel->brushq1.lightmapupdateflags[surfacenum]) @@ -2551,18 +2770,21 @@ static void Mod_Q1BSP_LoadFaces(lump_t *l) tsize = (surface->lightmapinfo->extents[1] >> 4) + 1; stainmapsize += ssize * tsize * 3; - if (!lightmaptexture || !Mod_Q1BSP_AllocLightmapBlock(&allocState, 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); + loadmodel->brushq3.num_mergedlightmaps = lightmapnumber + 1; + loadmodel->brushq3.data_lightmaps = (rtexture_t **)Mem_Realloc(loadmodel->mempool, loadmodel->brushq3.data_lightmaps, loadmodel->brushq3.num_mergedlightmaps * sizeof(loadmodel->brushq3.data_lightmaps[0])); + loadmodel->brushq3.data_deluxemaps = (rtexture_t **)Mem_Realloc(loadmodel->mempool, loadmodel->brushq3.data_deluxemaps, loadmodel->brushq3.num_mergedlightmaps * sizeof(loadmodel->brushq3.data_deluxemaps[0])); + loadmodel->brushq3.data_lightmaps[lightmapnumber] = lightmaptexture = R_LoadTexture2D(loadmodel->texturepool, va(vabuf, sizeof(vabuf), "lightmap%i", lightmapnumber), lightmapsize, lightmapsize, NULL, TEXTYPE_BGRA, TEXF_FORCELINEAR | TEXF_ALLOWUPDATES, -1, NULL); if (loadmodel->brushq1.nmaplightdata) - deluxemaptexture = R_LoadTexture2D(loadmodel->texturepool, va("deluxemap%i", lightmapnumber), lightmapsize, lightmapsize, NULL, TEXTYPE_BGRA, TEXF_FORCELINEAR | TEXF_PRECACHE, NULL); + loadmodel->brushq3.data_deluxemaps[lightmapnumber] = deluxemaptexture = R_LoadTexture2D(loadmodel->texturepool, va(vabuf, sizeof(vabuf), "deluxemap%i", lightmapnumber), lightmapsize, lightmapsize, NULL, TEXTYPE_BGRA, TEXF_FORCELINEAR | TEXF_ALLOWUPDATES, -1, NULL); lightmapnumber++; - init_alloc_lm_state (&allocState); - Mod_Q1BSP_AllocLightmapBlock(&allocState, lightmapsize, lightmapsize, ssize, tsize, &lightmapx, &lightmapy); + Mod_AllocLightmap_Reset(&allocState); + Mod_AllocLightmap_Block(&allocState, ssize, tsize, &lightmapx, &lightmapy); } surface->lightmaptexture = lightmaptexture; surface->deluxemaptexture = deluxemaptexture; @@ -2649,34 +2871,72 @@ static void Mod_Q1BSP_LoadNodes_RecursiveSetParent(mnode_t *node, mnode_t *paren } } -static void Mod_Q1BSP_LoadNodes(lump_t *l) +static void Mod_Q1BSP_LoadNodes(sizebuf_t *sb) { - int i, j, count, p; - dnode_t *in; + int i, j, count, p, child[2]; mnode_t *out; + int structsize = loadmodel->brush.isbsp2rmqe ? 32 : (loadmodel->brush.isbsp2 ? 44 : 24); - in = (dnode_t *)(mod_base + l->fileofs); - if (l->filelen % sizeof(*in)) + if (sb->cursize % structsize) Host_Error("Mod_Q1BSP_LoadNodes: funny lump size in %s",loadmodel->name); - count = l->filelen / sizeof(*in); + count = sb->cursize / structsize; + if (count == 0) + Host_Error("Mod_Q1BSP_LoadNodes: missing BSP tree in %s",loadmodel->name); out = (mnode_t *)Mem_Alloc(loadmodel->mempool, count*sizeof(*out)); loadmodel->brush.data_nodes = out; loadmodel->brush.num_nodes = count; - for ( i=0 ; imins[j] = LittleShort(in->mins[j]); - out->maxs[j] = LittleShort(in->maxs[j]); + p = MSG_ReadLittleLong(sb); + out->plane = loadmodel->brush.data_planes + p; + + if (loadmodel->brush.isbsp2rmqe) + { + child[0] = MSG_ReadLittleLong(sb); + child[1] = MSG_ReadLittleLong(sb); + out->mins[0] = MSG_ReadLittleShort(sb); + out->mins[1] = MSG_ReadLittleShort(sb); + out->mins[2] = MSG_ReadLittleShort(sb); + out->maxs[0] = MSG_ReadLittleShort(sb); + out->maxs[1] = MSG_ReadLittleShort(sb); + out->maxs[2] = MSG_ReadLittleShort(sb); + out->firstsurface = MSG_ReadLittleLong(sb); + out->numsurfaces = MSG_ReadLittleLong(sb); + } + else if (loadmodel->brush.isbsp2) + { + child[0] = MSG_ReadLittleLong(sb); + child[1] = MSG_ReadLittleLong(sb); + out->mins[0] = MSG_ReadLittleFloat(sb); + out->mins[1] = MSG_ReadLittleFloat(sb); + out->mins[2] = MSG_ReadLittleFloat(sb); + out->maxs[0] = MSG_ReadLittleFloat(sb); + out->maxs[1] = MSG_ReadLittleFloat(sb); + out->maxs[2] = MSG_ReadLittleFloat(sb); + out->firstsurface = MSG_ReadLittleLong(sb); + out->numsurfaces = MSG_ReadLittleLong(sb); } + else + { + child[0] = (unsigned short)MSG_ReadLittleShort(sb); + child[1] = (unsigned short)MSG_ReadLittleShort(sb); + if (child[0] >= count) + child[0] -= 65536; + if (child[1] >= count) + child[1] -= 65536; - p = LittleLong(in->planenum); - out->plane = loadmodel->brush.data_planes + p; + out->mins[0] = MSG_ReadLittleShort(sb); + out->mins[1] = MSG_ReadLittleShort(sb); + out->mins[2] = MSG_ReadLittleShort(sb); + out->maxs[0] = MSG_ReadLittleShort(sb); + out->maxs[1] = MSG_ReadLittleShort(sb); + out->maxs[2] = MSG_ReadLittleShort(sb); - out->firstsurface = (unsigned short)LittleShort(in->firstface); - out->numsurfaces = (unsigned short)LittleShort(in->numfaces); + out->firstsurface = (unsigned short)MSG_ReadLittleShort(sb); + out->numsurfaces = (unsigned short)MSG_ReadLittleShort(sb); + } for (j=0 ; j<2 ; j++) { @@ -2684,8 +2944,8 @@ static void Mod_Q1BSP_LoadNodes(lump_t *l) // arguire qbsp which can produce more than 32768 nodes, any value // below count is assumed to be a node number, any other value is // assumed to be a leaf number - p = (unsigned short)LittleShort(in->children[j]); - if (p < count) + p = child[j]; + if (p >= 0) { if (p < loadmodel->brush.num_nodes) out->children[j] = loadmodel->brush.data_nodes + p; @@ -2698,8 +2958,8 @@ static void Mod_Q1BSP_LoadNodes(lump_t *l) } else { - // note this uses 65535 intentionally, -1 is leaf 0 - p = 65535 - p; + // get leaf index as a positive value starting at 0 (-1 becomes 0, -2 becomes 1, etc) + p = -(p+1); if (p < loadmodel->brush.num_leafs) out->children[j] = (mnode_t *)(loadmodel->brush.data_leafs + p); else @@ -2715,16 +2975,15 @@ static void Mod_Q1BSP_LoadNodes(lump_t *l) Mod_Q1BSP_LoadNodes_RecursiveSetParent(loadmodel->brush.data_nodes, NULL); // sets nodes and leafs } -static void Mod_Q1BSP_LoadLeafs(lump_t *l) +static void Mod_Q1BSP_LoadLeafs(sizebuf_t *sb) { - dleaf_t *in; mleaf_t *out; - int i, j, count, p; + int i, j, count, p, firstmarksurface, nummarksurfaces; + int structsize = loadmodel->brush.isbsp2rmqe ? 32 : (loadmodel->brush.isbsp2 ? 44 : 28); - in = (dleaf_t *)(mod_base + l->fileofs); - if (l->filelen % sizeof(*in)) + if (sb->cursize % structsize) Host_Error("Mod_Q1BSP_LoadLeafs: funny lump size in %s",loadmodel->name); - count = l->filelen / sizeof(*in); + count = sb->cursize / structsize; out = (mleaf_t *)Mem_Alloc(loadmodel->mempool, count*sizeof(*out)); loadmodel->brush.data_leafs = out; @@ -2735,32 +2994,16 @@ static void Mod_Q1BSP_LoadLeafs(lump_t *l) loadmodel->brush.data_pvsclusters = (unsigned char *)Mem_Alloc(loadmodel->mempool, loadmodel->brush.num_pvsclusters * loadmodel->brush.num_pvsclusterbytes); memset(loadmodel->brush.data_pvsclusters, 0xFF, loadmodel->brush.num_pvsclusters * loadmodel->brush.num_pvsclusterbytes); - for ( i=0 ; imins[j] = LittleShort(in->mins[j]); - out->maxs[j] = LittleShort(in->maxs[j]); - } - - // FIXME: this function could really benefit from some error checking - - out->contents = LittleLong(in->contents); - - out->firstleafsurface = loadmodel->brush.data_leafsurfaces + (unsigned short)LittleShort(in->firstmarksurface); - out->numleafsurfaces = (unsigned short)LittleShort(in->nummarksurfaces); - 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; - out->numleafsurfaces = 0; - } + out->contents = MSG_ReadLittleLong(sb); out->clusterindex = i - 1; if (out->clusterindex >= loadmodel->brush.num_pvsclusters) out->clusterindex = -1; - p = LittleLong(in->visofs); + p = MSG_ReadLittleLong(sb); // ignore visofs errors on leaf 0 (solid) if (p >= 0 && out->clusterindex >= 0) { @@ -2770,14 +3013,61 @@ static void Mod_Q1BSP_LoadLeafs(lump_t *l) Mod_Q1BSP_DecompressVis(loadmodel->brushq1.data_compressedpvs + p, loadmodel->brushq1.data_compressedpvs + loadmodel->brushq1.num_compressedpvs, loadmodel->brush.data_pvsclusters + out->clusterindex * loadmodel->brush.num_pvsclusterbytes, loadmodel->brush.data_pvsclusters + (out->clusterindex + 1) * loadmodel->brush.num_pvsclusterbytes); } - for (j = 0;j < 4;j++) - out->ambient_sound_level[j] = in->ambient_level[j]; + if (loadmodel->brush.isbsp2rmqe) + { + out->mins[0] = MSG_ReadLittleShort(sb); + out->mins[1] = MSG_ReadLittleShort(sb); + out->mins[2] = MSG_ReadLittleShort(sb); + out->maxs[0] = MSG_ReadLittleShort(sb); + out->maxs[1] = MSG_ReadLittleShort(sb); + out->maxs[2] = MSG_ReadLittleShort(sb); + + firstmarksurface = MSG_ReadLittleLong(sb); + nummarksurfaces = MSG_ReadLittleLong(sb); + } + else if (loadmodel->brush.isbsp2) + { + out->mins[0] = MSG_ReadLittleFloat(sb); + out->mins[1] = MSG_ReadLittleFloat(sb); + out->mins[2] = MSG_ReadLittleFloat(sb); + out->maxs[0] = MSG_ReadLittleFloat(sb); + out->maxs[1] = MSG_ReadLittleFloat(sb); + out->maxs[2] = MSG_ReadLittleFloat(sb); + + firstmarksurface = MSG_ReadLittleLong(sb); + nummarksurfaces = MSG_ReadLittleLong(sb); + } + else + { + out->mins[0] = MSG_ReadLittleShort(sb); + out->mins[1] = MSG_ReadLittleShort(sb); + out->mins[2] = MSG_ReadLittleShort(sb); + out->maxs[0] = MSG_ReadLittleShort(sb); + out->maxs[1] = MSG_ReadLittleShort(sb); + out->maxs[2] = MSG_ReadLittleShort(sb); + + firstmarksurface = (unsigned short)MSG_ReadLittleShort(sb); + nummarksurfaces = (unsigned short)MSG_ReadLittleShort(sb); + } + + if (firstmarksurface >= 0 && firstmarksurface + nummarksurfaces <= loadmodel->brush.num_leafsurfaces) + { + out->firstleafsurface = loadmodel->brush.data_leafsurfaces + firstmarksurface; + out->numleafsurfaces = nummarksurfaces; + } + else + { + Con_Printf("Mod_Q1BSP_LoadLeafs: invalid leafsurface range %i:%i outside range %i:%i\n", firstmarksurface, firstmarksurface+nummarksurfaces, 0, loadmodel->brush.num_leafsurfaces); + out->firstleafsurface = NULL; + out->numleafsurfaces = 0; + } - // FIXME: Insert caustics here + for (j = 0;j < 4;j++) + out->ambient_sound_level[j] = MSG_ReadByte(sb); } } -qboolean Mod_Q1BSP_CheckWaterAlphaSupport(void) +static qboolean Mod_Q1BSP_CheckWaterAlphaSupport(void) { int i, j; mleaf_t *leaf; @@ -2800,17 +3090,16 @@ qboolean Mod_Q1BSP_CheckWaterAlphaSupport(void) return false; } -static void Mod_Q1BSP_LoadClipnodes(lump_t *l, hullinfo_t *hullinfo) +static void Mod_Q1BSP_LoadClipnodes(sizebuf_t *sb, hullinfo_t *hullinfo) { - dclipnode_t *in; mclipnode_t *out; int i, count; hull_t *hull; + int structsize = loadmodel->brush.isbsp2 ? 12 : 8; - in = (dclipnode_t *)(mod_base + l->fileofs); - if (l->filelen % sizeof(*in)) + if (sb->cursize % structsize) Host_Error("Mod_Q1BSP_LoadClipnodes: funny lump size in %s",loadmodel->name); - count = l->filelen / sizeof(*in); + count = sb->cursize / structsize; out = (mclipnode_t *)Mem_Alloc(loadmodel->mempool, count*sizeof(*out)); loadmodel->brushq1.clipnodes = out; @@ -2832,18 +3121,30 @@ static void Mod_Q1BSP_LoadClipnodes(lump_t *l, hullinfo_t *hullinfo) VectorSubtract(hull->clip_maxs, hull->clip_mins, hull->clip_size); } - for (i=0 ; iplanenum = LittleLong(in->planenum); - // LordHavoc: this code supports arguire qbsp's broken clipnodes indices (more than 32768 clipnodes), values above count are assumed to be contents values - out->children[0] = (unsigned short)LittleShort(in->children[0]); - out->children[1] = (unsigned short)LittleShort(in->children[1]); - if (out->children[0] >= count) - out->children[0] -= 65536; - if (out->children[1] >= count) - out->children[1] -= 65536; + out->planenum = MSG_ReadLittleLong(sb); if (out->planenum < 0 || out->planenum >= loadmodel->brush.num_planes) - Host_Error("Corrupt clipping hull(out of range planenum)"); + Host_Error("%s: Corrupt clipping hull(out of range planenum)", loadmodel->name); + if (loadmodel->brush.isbsp2) + { + out->children[0] = MSG_ReadLittleLong(sb); + out->children[1] = MSG_ReadLittleLong(sb); + if (out->children[0] >= count) + Host_Error("%s: Corrupt clipping hull (invalid child index)", loadmodel->name); + if (out->children[1] >= count) + Host_Error("%s: Corrupt clipping hull (invalid child index)", loadmodel->name); + } + else + { + // LordHavoc: this code supports arguire qbsp's broken clipnodes indices (more than 32768 clipnodes), values above count are assumed to be contents values + out->children[0] = (unsigned short)MSG_ReadLittleShort(sb); + out->children[1] = (unsigned short)MSG_ReadLittleShort(sb); + if (out->children[0] >= count) + out->children[0] -= 65536; + if (out->children[1] >= count) + out->children[1] -= 65536; + } } } @@ -2873,66 +3174,95 @@ static void Mod_Q1BSP_MakeHull0(void) } } -static void Mod_Q1BSP_LoadLeaffaces(lump_t *l) +static void Mod_Q1BSP_LoadLeaffaces(sizebuf_t *sb) { int i, j; - short *in; + int structsize = loadmodel->brush.isbsp2 ? 4 : 2; - in = (short *)(mod_base + l->fileofs); - if (l->filelen % sizeof(*in)) + if (sb->cursize % structsize) Host_Error("Mod_Q1BSP_LoadLeaffaces: funny lump size in %s",loadmodel->name); - loadmodel->brush.num_leafsurfaces = l->filelen / sizeof(*in); + loadmodel->brush.num_leafsurfaces = sb->cursize / structsize; loadmodel->brush.data_leafsurfaces = (int *)Mem_Alloc(loadmodel->mempool, loadmodel->brush.num_leafsurfaces * sizeof(int)); - for (i = 0;i < loadmodel->brush.num_leafsurfaces;i++) + if (loadmodel->brush.isbsp2) { - j = (unsigned short) LittleShort(in[i]); - if (j >= loadmodel->num_surfaces) - Host_Error("Mod_Q1BSP_LoadLeaffaces: bad surface number"); - loadmodel->brush.data_leafsurfaces[i] = j; + for (i = 0;i < loadmodel->brush.num_leafsurfaces;i++) + { + j = MSG_ReadLittleLong(sb); + if (j < 0 || j >= loadmodel->num_surfaces) + Host_Error("Mod_Q1BSP_LoadLeaffaces: bad surface number"); + loadmodel->brush.data_leafsurfaces[i] = j; + } + } + else + { + for (i = 0;i < loadmodel->brush.num_leafsurfaces;i++) + { + j = (unsigned short) MSG_ReadLittleShort(sb); + if (j >= loadmodel->num_surfaces) + Host_Error("Mod_Q1BSP_LoadLeaffaces: bad surface number"); + loadmodel->brush.data_leafsurfaces[i] = j; + } } } -static void Mod_Q1BSP_LoadSurfedges(lump_t *l) +static void Mod_Q1BSP_LoadSurfedges(sizebuf_t *sb) { int i; - int *in; + int structsize = 4; - in = (int *)(mod_base + l->fileofs); - if (l->filelen % sizeof(*in)) + if (sb->cursize % structsize) Host_Error("Mod_Q1BSP_LoadSurfedges: funny lump size in %s",loadmodel->name); - loadmodel->brushq1.numsurfedges = l->filelen / sizeof(*in); + loadmodel->brushq1.numsurfedges = sb->cursize / structsize; loadmodel->brushq1.surfedges = (int *)Mem_Alloc(loadmodel->mempool, loadmodel->brushq1.numsurfedges * sizeof(int)); for (i = 0;i < loadmodel->brushq1.numsurfedges;i++) - loadmodel->brushq1.surfedges[i] = LittleLong(in[i]); + loadmodel->brushq1.surfedges[i] = MSG_ReadLittleLong(sb); } -static void Mod_Q1BSP_LoadPlanes(lump_t *l) +static void Mod_Q1BSP_LoadPlanes(sizebuf_t *sb) { int i; mplane_t *out; - dplane_t *in; + int structsize = 20; - in = (dplane_t *)(mod_base + l->fileofs); - if (l->filelen % sizeof(*in)) + if (sb->cursize % structsize) Host_Error("Mod_Q1BSP_LoadPlanes: funny lump size in %s", loadmodel->name); - - loadmodel->brush.num_planes = l->filelen / sizeof(*in); + loadmodel->brush.num_planes = sb->cursize / structsize; loadmodel->brush.data_planes = out = (mplane_t *)Mem_Alloc(loadmodel->mempool, loadmodel->brush.num_planes * sizeof(*out)); - for (i = 0;i < loadmodel->brush.num_planes;i++, in++, out++) + for (i = 0;i < loadmodel->brush.num_planes;i++, out++) { - out->normal[0] = LittleFloat(in->normal[0]); - out->normal[1] = LittleFloat(in->normal[1]); - out->normal[2] = LittleFloat(in->normal[2]); - out->dist = LittleFloat(in->dist); - + out->normal[0] = MSG_ReadLittleFloat(sb); + out->normal[1] = MSG_ReadLittleFloat(sb); + out->normal[2] = MSG_ReadLittleFloat(sb); + out->dist = MSG_ReadLittleFloat(sb); + MSG_ReadLittleLong(sb); // type is not used, we use PlaneClassify PlaneClassify(out); } } +// fixes up sky surfaces that have SKY contents behind them, so that they do not cast shadows (e1m5 logo shadow trick). +static void Mod_Q1BSP_AssignNoShadowSkySurfaces(dp_model_t *mod) +{ + int i; + msurface_t *surface; + vec3_t center; + int contents; + for (i = 0, surface = mod->data_surfaces + mod->firstmodelsurface; i < mod->nummodelsurfaces; i++, surface++) + { + if (surface->texture->basematerialflags & MATERIALFLAG_SKY) + { + // check if the point behind the surface polygon is SOLID or SKY contents + VectorMAMAM(0.5f, surface->mins, 0.5f, surface->maxs, -0.25f, mod->surfmesh.data_normal3f + 3*surface->num_firstvertex, center); + contents = Mod_Q1BSP_PointSuperContents(mod, 0, center); + if (!(contents & SUPERCONTENTS_SOLID)) + surface->texture = surface->texture->skynoshadowtexture; + } + } +} + static void Mod_Q1BSP_LoadMapBrushes(void) { #if 0 @@ -2947,12 +3277,12 @@ static void Mod_Q1BSP_LoadMapBrushes(void) if (!maptext) return; text = maptext; - if (!COM_ParseToken_Simple(&data, false, false)) + if (!COM_ParseToken_Simple(&data, false, false, true)) return; // error submodel = 0; for (;;) { - if (!COM_ParseToken_Simple(&data, false, false)) + if (!COM_ParseToken_Simple(&data, false, false, true)) break; if (com_token[0] != '{') return; // error @@ -2963,7 +3293,7 @@ static void Mod_Q1BSP_LoadMapBrushes(void) brushes = Mem_Alloc(loadmodel->mempool, maxbrushes * sizeof(mbrush_t)); for (;;) { - if (!COM_ParseToken_Simple(&data, false, false)) + if (!COM_ParseToken_Simple(&data, false, false, true)) return; // error if (com_token[0] == '}') break; // end of entity @@ -2987,7 +3317,7 @@ static void Mod_Q1BSP_LoadMapBrushes(void) } for (;;) { - if (!COM_ParseToken_Simple(&data, false, false)) + if (!COM_ParseToken_Simple(&data, false, false, true)) return; // error if (com_token[0] == '}') break; // end of brush @@ -2996,25 +3326,25 @@ static void Mod_Q1BSP_LoadMapBrushes(void) // FIXME: support hl .map format for (pointnum = 0;pointnum < 3;pointnum++) { - COM_ParseToken_Simple(&data, false, false); + COM_ParseToken_Simple(&data, false, false, true); for (componentnum = 0;componentnum < 3;componentnum++) { - COM_ParseToken_Simple(&data, false, false); + COM_ParseToken_Simple(&data, false, false, true); point[pointnum][componentnum] = atof(com_token); } - COM_ParseToken_Simple(&data, false, false); + COM_ParseToken_Simple(&data, false, false, true); } - COM_ParseToken_Simple(&data, false, false); + COM_ParseToken_Simple(&data, false, false, true); strlcpy(facetexture, com_token, sizeof(facetexture)); - COM_ParseToken_Simple(&data, false, false); + COM_ParseToken_Simple(&data, false, false, true); //scroll_s = atof(com_token); - COM_ParseToken_Simple(&data, false, false); + COM_ParseToken_Simple(&data, false, false, true); //scroll_t = atof(com_token); - COM_ParseToken_Simple(&data, false, false); + COM_ParseToken_Simple(&data, false, false, true); //rotate = atof(com_token); - COM_ParseToken_Simple(&data, false, false); + COM_ParseToken_Simple(&data, false, false, true); //scale_s = atof(com_token); - COM_ParseToken_Simple(&data, false, false); + COM_ParseToken_Simple(&data, false, false, true); //scale_t = atof(com_token); TriangleNormal(point[0], point[1], point[2], planenormal); VectorNormalizeDouble(planenormal); @@ -3042,26 +3372,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) { @@ -3084,8 +3395,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 = (int)Mem_ExpandableArray_IndexRange(&portalarray); + portal_t *p; mportal_t *portal; mvertex_t *point; mleaf_t *leaf, *endleaf; @@ -3094,16 +3405,21 @@ static void Mod_Q1BSP_FinalizePortals(void) // leafs (because qbsp is very sloppy) leaf = loadmodel->brush.data_leafs; endleaf = leaf + loadmodel->brush.num_leafs; - for (;leaf < endleaf;leaf++) + if (mod_recalculatenodeboxes.integer) { - VectorSet(leaf->mins, 2000000000, 2000000000, 2000000000); - VectorSet(leaf->maxs, -2000000000, -2000000000, -2000000000); + for (;leaf < endleaf;leaf++) + { + 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) @@ -3111,7 +3427,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; @@ -3123,12 +3438,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 @@ -3182,25 +3496,27 @@ static void Mod_Q1BSP_FinalizePortals(void) portal++; } // add the portal's polygon points to the leaf bounding boxes - for (i = 0;i < 2;i++) + if (mod_recalculatenodeboxes.integer) { - leaf = (mleaf_t *)p->nodes[i]; - for (j = 0;j < p->numpoints;j++) + for (i = 0;i < 2;i++) { - if (leaf->mins[0] > p->points[j*3+0]) leaf->mins[0] = p->points[j*3+0]; - if (leaf->mins[1] > p->points[j*3+1]) leaf->mins[1] = p->points[j*3+1]; - if (leaf->mins[2] > p->points[j*3+2]) leaf->mins[2] = p->points[j*3+2]; - if (leaf->maxs[0] < p->points[j*3+0]) leaf->maxs[0] = p->points[j*3+0]; - if (leaf->maxs[1] < p->points[j*3+1]) leaf->maxs[1] = p->points[j*3+1]; - if (leaf->maxs[2] < p->points[j*3+2]) leaf->maxs[2] = p->points[j*3+2]; + leaf = (mleaf_t *)p->nodes[i]; + for (j = 0;j < p->numpoints;j++) + { + if (leaf->mins[0] > p->points[j*3+0]) leaf->mins[0] = p->points[j*3+0]; + if (leaf->mins[1] > p->points[j*3+1]) leaf->mins[1] = p->points[j*3+1]; + if (leaf->mins[2] > p->points[j*3+2]) leaf->mins[2] = p->points[j*3+2]; + if (leaf->maxs[0] < p->points[j*3+0]) leaf->maxs[0] = p->points[j*3+0]; + if (leaf->maxs[1] < p->points[j*3+1]) leaf->maxs[1] = p->points[j*3+1]; + if (leaf->maxs[2] < p->points[j*3+2]) leaf->maxs[2] = p->points[j*3+2]; + } } } } - FreePortal(p); - p = pnext; } // now recalculate the node bounding boxes from the leafs - Mod_Q1BSP_RecursiveRecalcNodeBBox(loadmodel->brush.data_nodes); + if (mod_recalculatenodeboxes.integer) + Mod_Q1BSP_RecursiveRecalcNodeBBox(loadmodel->brush.data_nodes + loadmodel->brushq1.hulls[0].firstclipnode); } /* @@ -3277,6 +3593,9 @@ static void RemovePortalFromNodes(portal_t *portal) } #define PORTAL_DIST_EPSILON (1.0 / 32.0) +static double *portalpointsbuffer; +static int portalpointsbufferoffset; +static int portalpointsbuffersize; static void Mod_Q1BSP_RecursiveNodePortals(mnode_t *node) { int i, side; @@ -3284,12 +3603,23 @@ static void Mod_Q1BSP_RecursiveNodePortals(mnode_t *node) mplane_t clipplane, *plane; portal_t *portal, *nextportal, *nodeportal, *splitportal, *temp; int numfrontpoints, numbackpoints; - double frontpoints[3*MAX_PORTALPOINTS], backpoints[3*MAX_PORTALPOINTS]; + double *frontpoints, *backpoints; // if a leaf, we're done if (!node->plane) return; + // get some space for our clipping operations to use + if (portalpointsbuffersize < portalpointsbufferoffset + 6*MAX_PORTALPOINTS) + { + portalpointsbuffersize = portalpointsbufferoffset * 2; + portalpointsbuffer = (double *)Mem_Realloc(loadmodel->mempool, portalpointsbuffer, portalpointsbuffersize * sizeof(*portalpointsbuffer)); + } + frontpoints = portalpointsbuffer + portalpointsbufferoffset; + portalpointsbufferoffset += 3*MAX_PORTALPOINTS; + backpoints = portalpointsbuffer + portalpointsbufferoffset; + portalpointsbufferoffset += 3*MAX_PORTALPOINTS; + plane = node->plane; front = node->children[0]; @@ -3299,13 +3629,13 @@ 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) PolygonD_QuadForPlane(nodeportal->points, nodeportal->plane.normal[0], nodeportal->plane.normal[1], nodeportal->plane.normal[2], nodeportal->plane.dist, 1024.0*1024.0*1024.0); nodeportal->numpoints = 4; - side = 0; // shut up compiler warning + // side = 0; // shut up compiler warning -> should be no longer needed, Host_Error is declared noreturn now for (portal = (portal_t *)node->portals;portal;portal = portal->next[side]) { clipplane = portal->plane; @@ -3320,7 +3650,10 @@ static void Mod_Q1BSP_RecursiveNodePortals(mnode_t *node) side = 1; } else + { Host_Error("Mod_Q1BSP_RecursiveNodePortals: mislinked portal"); + side = 0; // hush warning + } for (i = 0;i < nodeportal->numpoints*3;i++) frontpoints[i] = nodeportal->points[i]; @@ -3353,7 +3686,10 @@ static void Mod_Q1BSP_RecursiveNodePortals(mnode_t *node) else if (portal->nodes[1] == node) side = 1; else + { Host_Error("Mod_Q1BSP_RecursiveNodePortals: mislinked portal"); + side = 0; // hush warning + } nextportal = portal->next[side]; if (!portal->numpoints) continue; @@ -3382,7 +3718,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; @@ -3407,13 +3743,23 @@ static void Mod_Q1BSP_RecursiveNodePortals(mnode_t *node) Mod_Q1BSP_RecursiveNodePortals(front); Mod_Q1BSP_RecursiveNodePortals(back); + + portalpointsbufferoffset -= 6*MAX_PORTALPOINTS; } 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)); + portalpointsbufferoffset = 0; + portalpointsbuffersize = 6*MAX_PORTALPOINTS*128; + portalpointsbuffer = (double *)Mem_Alloc(loadmodel->mempool, portalpointsbuffersize * sizeof(*portalpointsbuffer)); + Mod_Q1BSP_RecursiveNodePortals(loadmodel->brush.data_nodes + loadmodel->brushq1.hulls[0].firstclipnode); + Mem_Free(portalpointsbuffer); + portalpointsbuffer = NULL; + portalpointsbufferoffset = 0; + portalpointsbuffersize = 0; Mod_Q1BSP_FinalizePortals(); + Mem_ExpandableArray_FreeArray(&portalarray); } //Returns PVS data for a given point @@ -3421,7 +3767,7 @@ static void Mod_Q1BSP_MakePortals(void) 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) @@ -3462,14 +3808,14 @@ static int Mod_Q1BSP_FatPVS(dp_model_t *model, const vec3_t org, vec_t radius, u { int bytes = model->brush.num_pvsclusterbytes; bytes = min(bytes, pvsbufferlength); - if (r_novis.integer || !model->brush.num_pvsclusters || !Mod_Q1BSP_GetPVS(model, org)) + if (r_novis.integer || r_trippy.integer || !model->brush.num_pvsclusters || !Mod_Q1BSP_GetPVS(model, org)) { memset(pvsbuffer, 0xFF, bytes); return bytes; } 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; } @@ -3506,38 +3852,61 @@ static void Mod_Q1BSP_RoundUpToHullSize(dp_model_t *cmodel, const vec3_t inmins, VectorAdd(inmins, hull->clip_size, outmaxs); } +void Mod_CollisionBIH_TraceLineAgainstSurfaces(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 skipsupercontentsmask, int skipmaterialflagsmask); + 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; + sizebuf_t lumpsb[HEADER_LUMPS]; + mmodel_t *bm; float dist, modelyawradius, modelradius; msurface_t *surface; - int numshadowmeshtriangles; hullinfo_t hullinfo; int totalstylesurfaces, totalstyles, stylecounts[256], remapstyles[256]; model_brush_lightstyleinfo_t styleinfo[256]; unsigned char *datapointer; + sizebuf_t sb; - mod->modeldatatypestring = "Q1BSP"; + MSG_InitReadBuffer(&sb, (unsigned char *)buffer, (unsigned char *)bufferend - (unsigned char *)buffer); mod->type = mod_brushq1; - 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.ishlbsp = false; + mod->brush.isbsp2rmqe = false; + mod->brush.isbsp2 = false; + mod->brush.isq2bsp = false; + mod->brush.isq3bsp = false; + mod->brush.skymasking = true; + i = MSG_ReadLittleLong(&sb); + switch(i) + { + case BSPVERSION: + mod->modeldatatypestring = "Q1BSP"; + break; + case 30: + mod->brush.ishlbsp = true; + mod->modeldatatypestring = "HLBSP"; + break; + case ('2' + 'P' * 256 + 'S' * 65536 + 'B' * 16777216): + mod->brush.isbsp2 = true; + mod->brush.isbsp2rmqe = true; // like bsp2 except leaf/node bounds are 16bit (unexpanded) + mod->modeldatatypestring = "Q1BSP2rmqe"; + break; + case ('B' + 'S' * 256 + 'P' * 65536 + '2' * 16777216): + mod->brush.isbsp2 = true; + mod->modeldatatypestring = "Q1BSP2"; + break; + default: + mod->modeldatatypestring = "Unknown BSP"; + Host_Error("Mod_Q1BSP_Load: %s has wrong version number %i: supported versions are 29 (Quake), 30 (Half-Life), \"BSP2\" or \"2PSB\" (rmqe)", mod->name, i); + return; + } // fill in hull info VectorClear (hullinfo.hullsizes[0][0]); VectorClear (hullinfo.hullsizes[0][1]); if (mod->brush.ishlbsp) { - mod->modeldatatypestring = "HLBSP"; - hullinfo.filehulls = 4; VectorSet (hullinfo.hullsizes[1][0], -16, -16, -36); VectorSet (hullinfo.hullsizes[1][1], 16, 16, 36); @@ -3556,11 +3925,13 @@ void Mod_Q1BSP_Load(dp_model_t *mod, void *buffer, void *bufferend) } // 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); + int offset = MSG_ReadLittleLong(&sb); + int size = MSG_ReadLittleLong(&sb); + if (offset < 0 || offset + size > sb.cursize) + Host_Error("Mod_Q1BSP_Load: %s has invalid lump %i (offset %i, size %i, file size %i)\n", mod->name, i, offset, size, (int)sb.cursize); + MSG_InitReadBuffer(&lumpsb[i], sb.data + offset, size); } mod->soundfromcenter = true; @@ -3568,6 +3939,7 @@ void Mod_Q1BSP_Load(dp_model_t *mod, void *buffer, void *bufferend) mod->TraceLine = Mod_Q1BSP_TraceLine; mod->TracePoint = Mod_Q1BSP_TracePoint; mod->PointSuperContents = Mod_Q1BSP_PointSuperContents; + mod->TraceLineAgainstSurfaces = Mod_Q1BSP_TraceLineAgainstSurfaces; mod->brush.TraceLineOfSight = Mod_Q1BSP_TraceLineOfSight; mod->brush.SuperContentsFromNativeContents = Mod_Q1BSP_SuperContentsFromNativeContents; mod->brush.NativeContentsFromSuperContents = Mod_Q1BSP_NativeContentsFromSuperContents; @@ -3585,11 +3957,10 @@ void Mod_Q1BSP_Load(dp_model_t *mod, void *buffer, void *bufferend) 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 @@ -3598,60 +3969,53 @@ void Mod_Q1BSP_Load(dp_model_t *mod, void *buffer, void *bufferend) mod->brush.qw_md4sum2 = 0; for (i = 0;i < HEADER_LUMPS;i++) { + int temp; if (i == LUMP_ENTITIES) continue; - mod->brush.qw_md4sum ^= LittleLong(Com_BlockChecksum(mod_base + header->lumps[i].fileofs, header->lumps[i].filelen)); + temp = Com_BlockChecksum(lumpsb[i].data, lumpsb[i].cursize); + mod->brush.qw_md4sum ^= LittleLong(temp); if (i == LUMP_VISIBILITY || i == LUMP_LEAFS || i == LUMP_NODES) continue; - mod->brush.qw_md4sum2 ^= LittleLong(Com_BlockChecksum(mod_base + header->lumps[i].fileofs, header->lumps[i].filelen)); - } - - Mod_Q1BSP_LoadEntities(&header->lumps[LUMP_ENTITIES]); - Mod_Q1BSP_LoadVertexes(&header->lumps[LUMP_VERTEXES]); - Mod_Q1BSP_LoadEdges(&header->lumps[LUMP_EDGES]); - Mod_Q1BSP_LoadSurfedges(&header->lumps[LUMP_SURFEDGES]); - Mod_Q1BSP_LoadTextures(&header->lumps[LUMP_TEXTURES]); - Mod_Q1BSP_LoadLighting(&header->lumps[LUMP_LIGHTING]); - Mod_Q1BSP_LoadPlanes(&header->lumps[LUMP_PLANES]); - Mod_Q1BSP_LoadTexinfo(&header->lumps[LUMP_TEXINFO]); - Mod_Q1BSP_LoadFaces(&header->lumps[LUMP_FACES]); - Mod_Q1BSP_LoadLeaffaces(&header->lumps[LUMP_MARKSURFACES]); - Mod_Q1BSP_LoadVisibility(&header->lumps[LUMP_VISIBILITY]); + mod->brush.qw_md4sum2 ^= LittleLong(temp); + } + + Mod_Q1BSP_LoadEntities(&lumpsb[LUMP_ENTITIES]); + Mod_Q1BSP_LoadVertexes(&lumpsb[LUMP_VERTEXES]); + Mod_Q1BSP_LoadEdges(&lumpsb[LUMP_EDGES]); + Mod_Q1BSP_LoadSurfedges(&lumpsb[LUMP_SURFEDGES]); + Mod_Q1BSP_LoadTextures(&lumpsb[LUMP_TEXTURES]); + Mod_Q1BSP_LoadLighting(&lumpsb[LUMP_LIGHTING]); + Mod_Q1BSP_LoadPlanes(&lumpsb[LUMP_PLANES]); + Mod_Q1BSP_LoadTexinfo(&lumpsb[LUMP_TEXINFO]); + Mod_Q1BSP_LoadFaces(&lumpsb[LUMP_FACES]); + Mod_Q1BSP_LoadLeaffaces(&lumpsb[LUMP_MARKSURFACES]); + Mod_Q1BSP_LoadVisibility(&lumpsb[LUMP_VISIBILITY]); // load submodels before leafs because they contain the number of vis leafs - Mod_Q1BSP_LoadSubmodels(&header->lumps[LUMP_MODELS], &hullinfo); - Mod_Q1BSP_LoadLeafs(&header->lumps[LUMP_LEAFS]); - Mod_Q1BSP_LoadNodes(&header->lumps[LUMP_NODES]); - Mod_Q1BSP_LoadClipnodes(&header->lumps[LUMP_CLIPNODES], &hullinfo); + Mod_Q1BSP_LoadSubmodels(&lumpsb[LUMP_MODELS], &hullinfo); + Mod_Q1BSP_LoadLeafs(&lumpsb[LUMP_LEAFS]); + Mod_Q1BSP_LoadNodes(&lumpsb[LUMP_NODES]); + Mod_Q1BSP_LoadClipnodes(&lumpsb[LUMP_CLIPNODES], &hullinfo); + + for (i = 0; i < HEADER_LUMPS; i++) + if (lumpsb[i].readcount != lumpsb[i].cursize && i != LUMP_TEXTURES && i != LUMP_LIGHTING) + Host_Error("Lump %i incorrectly loaded (readcount %i, size %i)\n", i, lumpsb[i].readcount, lumpsb[i].cursize); // check if the map supports transparent water rendering loadmodel->brush.supportwateralpha = Mod_Q1BSP_CheckWaterAlphaSupport(); + // we don't need the compressed pvs data anymore if (mod->brushq1.data_compressedpvs) Mem_Free(mod->brushq1.data_compressedpvs); mod->brushq1.data_compressedpvs = NULL; mod->brushq1.num_compressedpvs = 0; Mod_Q1BSP_MakeHull0(); - Mod_Q1BSP_MakePortals(); + if (mod_bsp_portalize.integer) + Mod_Q1BSP_MakePortals(); mod->numframes = 2; // regular and alternate animation mod->numskins = 1; - mainmempool = mod->mempool; - - // 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++) - { - 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++) - 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); - if (loadmodel->brush.numsubmodels) loadmodel->brush.submodels = (dp_model_t **)Mem_Alloc(loadmodel->mempool, loadmodel->brush.numsubmodels * sizeof(dp_model_t *)); @@ -3707,7 +4071,6 @@ void Mod_Q1BSP_Load(dp_model_t *mod, void *buffer, void *bufferend) // 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; @@ -3735,6 +4098,12 @@ void Mod_Q1BSP_Load(dp_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); + + // this has to occur after hull info has been set, as it uses Mod_Q1BSP_PointSuperContents + Mod_Q1BSP_AssignNoShadowSkySurfaces(mod); + // make the model surface list (used by shadowing/lighting) mod->sortedmodelsurfaces = (int *)datapointer;datapointer += mod->nummodelsurfaces * sizeof(int); Mod_MakeSortedSurfaces(mod); @@ -3774,7 +4143,7 @@ void Mod_Q1BSP_Load(dp_model_t *mod, void *buffer, void *bufferend) 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)) + if (surface->texture->basematerialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION | MATERIALFLAG_REFLECTION | MATERIALFLAG_CAMERA)) break; if (j < mod->nummodelsurfaces) mod->DrawAddWaterPlanes = R_Q1BSP_DrawAddWaterPlanes; @@ -3823,452 +4192,1000 @@ void Mod_Q1BSP_Load(dp_model_t *mod, void *buffer, void *bufferend) Con_Printf("warning: empty submodel *%i in %s\n", i+1, loadmodel->name); } //mod->brushq1.num_visleafs = bm->visleafs; - } - Mod_Q1BSP_LoadMapBrushes(); + // build a Bounding Interval Hierarchy for culling triangles in light rendering + Mod_MakeCollisionBIH(mod, true, &mod->render_bih); - //Mod_Q1BSP_ProcessLightList(); + if (mod_q1bsp_polygoncollisions.integer) + { + mod->collision_bih = mod->render_bih; + // point traces and contents checks still use the bsp tree + mod->TraceLine = Mod_CollisionBIH_TraceLine; + mod->TraceBox = Mod_CollisionBIH_TraceBox; + mod->TraceBrush = Mod_CollisionBIH_TraceBrush; + mod->TraceLineAgainstSurfaces = Mod_CollisionBIH_TraceLineAgainstSurfaces; + } - if (developer.integer >= 10) - Con_Printf("Some stats for q1bsp model \"%s\": %i faces, %i nodes, %i leafs, %i visleafs, %i visleafportals\n", loadmodel->name, loadmodel->num_surfaces, loadmodel->brush.num_nodes, loadmodel->brush.num_leafs, mod->brush.num_pvsclusters, loadmodel->brush.num_portals); -} + // generate VBOs and other shared data before cloning submodels + if (i == 0) + { + Mod_BuildVBOs(); + Mod_Q1BSP_LoadMapBrushes(); + //Mod_Q1BSP_ProcessLightList(); + } + } -static void Mod_Q2BSP_LoadEntities(lump_t *l) -{ + Con_DPrintf("Stats for q1bsp model \"%s\": %i faces, %i nodes, %i leafs, %i visleafs, %i visleafportals, mesh: %i vertices, %i triangles, %i surfaces\n", loadmodel->name, loadmodel->num_surfaces, loadmodel->brush.num_nodes, loadmodel->brush.num_leafs, mod->brush.num_pvsclusters, loadmodel->brush.num_portals, loadmodel->surfmesh.num_vertices, loadmodel->surfmesh.num_triangles, loadmodel->num_surfaces); } -static void Mod_Q2BSP_LoadPlanes(lump_t *l) +int Mod_Q2BSP_SuperContentsFromNativeContents(int nativecontents) { -/* - d_t *in; - m_t *out; - int i, count; - - in = (void *)(mod_base + l->fileofs); - if (l->filelen % sizeof(*in)) - Host_Error("Mod_Q2BSP_LoadPlanes: funny lump size in %s",loadmodel->name); - count = l->filelen / sizeof(*in); - out = Mem_Alloc(loadmodel->mempool, count * sizeof(*out)); - - loadmodel-> = out; - loadmodel->num = count; - - for (i = 0;i < count;i++, in++, out++) - { - } -*/ + int supercontents = 0; + if (nativecontents & CONTENTSQ2_SOLID) + supercontents |= SUPERCONTENTS_SOLID; + if (nativecontents & CONTENTSQ2_WATER) + supercontents |= SUPERCONTENTS_WATER; + if (nativecontents & CONTENTSQ2_SLIME) + supercontents |= SUPERCONTENTS_SLIME; + if (nativecontents & CONTENTSQ2_LAVA) + supercontents |= SUPERCONTENTS_LAVA; + if (nativecontents & CONTENTSQ2_MONSTER) + supercontents |= SUPERCONTENTS_BODY; + if (nativecontents & CONTENTSQ2_DEADMONSTER) + supercontents |= SUPERCONTENTS_CORPSE; + if (nativecontents & CONTENTSQ2_PLAYERCLIP) + supercontents |= SUPERCONTENTS_PLAYERCLIP; + if (nativecontents & CONTENTSQ2_MONSTERCLIP) + supercontents |= SUPERCONTENTS_MONSTERCLIP; + if (!(nativecontents & CONTENTSQ2_TRANSLUCENT)) + supercontents |= SUPERCONTENTS_OPAQUE; + return supercontents; } -static void Mod_Q2BSP_LoadVertices(lump_t *l) +int Mod_Q2BSP_NativeContentsFromSuperContents(int supercontents) { -/* - d_t *in; - m_t *out; - int i, count; - - in = (void *)(mod_base + l->fileofs); - if (l->filelen % sizeof(*in)) - Host_Error("Mod_Q2BSP_LoadVertices: funny lump size in %s",loadmodel->name); - count = l->filelen / sizeof(*in); - out = Mem_Alloc(loadmodel->mempool, count * sizeof(*out)); - - loadmodel-> = out; - loadmodel->num = count; - - for (i = 0;i < count;i++, in++, out++) - { - } -*/ + int nativecontents = 0; + if (supercontents & SUPERCONTENTS_SOLID) + nativecontents |= CONTENTSQ2_SOLID; + if (supercontents & SUPERCONTENTS_WATER) + nativecontents |= CONTENTSQ2_WATER; + if (supercontents & SUPERCONTENTS_SLIME) + nativecontents |= CONTENTSQ2_SLIME; + if (supercontents & SUPERCONTENTS_LAVA) + nativecontents |= CONTENTSQ2_LAVA; + if (supercontents & SUPERCONTENTS_BODY) + nativecontents |= CONTENTSQ2_MONSTER; + if (supercontents & SUPERCONTENTS_CORPSE) + nativecontents |= CONTENTSQ2_DEADMONSTER; + if (supercontents & SUPERCONTENTS_PLAYERCLIP) + nativecontents |= CONTENTSQ2_PLAYERCLIP; + if (supercontents & SUPERCONTENTS_MONSTERCLIP) + nativecontents |= CONTENTSQ2_MONSTERCLIP; + if (!(supercontents & SUPERCONTENTS_OPAQUE)) + nativecontents |= CONTENTSQ2_TRANSLUCENT; + return nativecontents; } -static void Mod_Q2BSP_LoadVisibility(lump_t *l) +static void Mod_Q2BSP_LoadVisibility(sizebuf_t *sb) { -/* - d_t *in; - m_t *out; int i, count; + loadmodel->brushq1.num_compressedpvs = 0; + loadmodel->brushq1.data_compressedpvs = NULL; + loadmodel->brush.num_pvsclusters = 0; + loadmodel->brush.num_pvsclusterbytes = 0; + loadmodel->brush.data_pvsclusters = NULL; - in = (void *)(mod_base + l->fileofs); - if (l->filelen % sizeof(*in)) - Host_Error("Mod_Q2BSP_LoadVisibility: funny lump size in %s",loadmodel->name); - count = l->filelen / sizeof(*in); - out = Mem_Alloc(loadmodel->mempool, count * sizeof(*out)); - - loadmodel-> = out; - loadmodel->num = count; + if (!sb->cursize) + return; - for (i = 0;i < count;i++, in++, out++) + count = MSG_ReadLittleLong(sb); + loadmodel->brush.num_pvsclusters = count; + loadmodel->brush.num_pvsclusterbytes = (count+7)>>3; + loadmodel->brush.data_pvsclusters = (unsigned char *)Mem_Alloc(loadmodel->mempool, count*loadmodel->brush.num_pvsclusterbytes); + for (i = 0;i < count;i++) { + int pvsofs = MSG_ReadLittleLong(sb); + /*int phsofs = */MSG_ReadLittleLong(sb); + // decompress the vis data for this cluster + // (note this accesses the underlying data store of sb, which is kind of evil) + Mod_Q1BSP_DecompressVis(sb->data + pvsofs, sb->data + sb->cursize, loadmodel->brush.data_pvsclusters + i * loadmodel->brush.num_pvsclusterbytes, loadmodel->brush.data_pvsclusters + (i+1) * loadmodel->brush.num_pvsclusterbytes); } -*/ + // hush the loading error check later - we had to do random access on this lump, so we didn't read to the end + sb->readcount = sb->cursize; } -static void Mod_Q2BSP_LoadNodes(lump_t *l) +static void Mod_Q2BSP_LoadNodes(sizebuf_t *sb) { -/* - d_t *in; - m_t *out; - int i, count; + int i, j, count, p, child[2]; + mnode_t *out; + int structsize = 28; - in = (void *)(mod_base + l->fileofs); - if (l->filelen % sizeof(*in)) + if (sb->cursize % structsize) Host_Error("Mod_Q2BSP_LoadNodes: funny lump size in %s",loadmodel->name); - count = l->filelen / sizeof(*in); - out = Mem_Alloc(loadmodel->mempool, count * sizeof(*out)); + count = sb->cursize / structsize; + if (count == 0) + Host_Error("Mod_Q2BSP_LoadNodes: missing BSP tree in %s",loadmodel->name); + out = (mnode_t *)Mem_Alloc(loadmodel->mempool, count*sizeof(*out)); - loadmodel-> = out; - loadmodel->num = count; + loadmodel->brush.data_nodes = out; + loadmodel->brush.num_nodes = count; - for (i = 0;i < count;i++, in++, out++) + for ( i=0 ; iplane = loadmodel->brush.data_planes + p; + child[0] = MSG_ReadLittleLong(sb); + child[1] = MSG_ReadLittleLong(sb); + out->mins[0] = MSG_ReadLittleShort(sb); + out->mins[1] = MSG_ReadLittleShort(sb); + out->mins[2] = MSG_ReadLittleShort(sb); + out->maxs[0] = MSG_ReadLittleShort(sb); + out->maxs[1] = MSG_ReadLittleShort(sb); + out->maxs[2] = MSG_ReadLittleShort(sb); + out->firstsurface = (unsigned short)MSG_ReadLittleShort(sb); + out->numsurfaces = (unsigned short)MSG_ReadLittleShort(sb); + if (out->firstsurface + out->numsurfaces > (unsigned int)loadmodel->num_surfaces) + { + Con_Printf("Mod_Q2BSP_LoadNodes: invalid surface index range %i+%i (file has only %i surfaces)\n", out->firstsurface, out->numsurfaces, loadmodel->num_surfaces); + out->firstsurface = 0; + out->numsurfaces = 0; + } + for (j=0 ; j<2 ; j++) + { + p = child[j]; + if (p >= 0) + { + if (p < loadmodel->brush.num_nodes) + out->children[j] = loadmodel->brush.data_nodes + p; + else + { + Con_Printf("Mod_Q2BSP_LoadNodes: invalid node index %i (file has only %i nodes)\n", p, loadmodel->brush.num_nodes); + // map it to the solid leaf + out->children[j] = (mnode_t *)loadmodel->brush.data_leafs; + } + } + else + { + // get leaf index as a positive value starting at 0 (-1 becomes 0, -2 becomes 1, etc) + p = -(p+1); + if (p < loadmodel->brush.num_leafs) + out->children[j] = (mnode_t *)(loadmodel->brush.data_leafs + p); + else + { + Con_Printf("Mod_Q2BSP_LoadNodes: invalid leaf index %i (file has only %i leafs)\n", p, loadmodel->brush.num_leafs); + // map it to the solid leaf + out->children[j] = (mnode_t *)loadmodel->brush.data_leafs; + } + } + } } -*/ -} - -static void Mod_Q2BSP_LoadTexInfo(lump_t *l) -{ -/* - d_t *in; - m_t *out; - int i, count; - - in = (void *)(mod_base + l->fileofs); - if (l->filelen % sizeof(*in)) - Host_Error("Mod_Q2BSP_LoadTexInfo: funny lump size in %s",loadmodel->name); - count = l->filelen / sizeof(*in); - out = Mem_Alloc(loadmodel->mempool, count * sizeof(*out)); - loadmodel-> = out; - loadmodel->num = count; - - for (i = 0;i < count;i++, in++, out++) - { - } -*/ + Mod_Q1BSP_LoadNodes_RecursiveSetParent(loadmodel->brush.data_nodes, NULL); // sets nodes and leafs } -static void Mod_Q2BSP_LoadFaces(lump_t *l) +static void Mod_Q2BSP_LoadTexinfo(sizebuf_t *sb) { -/* - d_t *in; - m_t *out; - int i, count; - - in = (void *)(mod_base + l->fileofs); - if (l->filelen % sizeof(*in)) - Host_Error("Mod_Q2BSP_LoadFaces: funny lump size in %s",loadmodel->name); - count = l->filelen / sizeof(*in); - out = Mem_Alloc(loadmodel->mempool, count * sizeof(*out)); - - loadmodel-> = out; - loadmodel->num = count; + mtexinfo_t *out; + int i, l, count; + int structsize = 76; + int maxtextures = 1024; // hardcoded limit of quake2 engine, so we may as well use it as an upper bound + char filename[MAX_QPATH]; + + if (sb->cursize % structsize) + Host_Error("Mod_Q2BSP_LoadTexinfo: funny lump size in %s",loadmodel->name); + count = sb->cursize / structsize; + out = (mtexinfo_t *)Mem_Alloc(loadmodel->mempool, count * sizeof(*out)); + loadmodel->brushq1.texinfo = out; + loadmodel->brushq1.numtexinfo = count; + loadmodel->num_texturesperskin = 0; + loadmodel->data_textures = (texture_t*)Mem_Alloc(loadmodel->mempool, maxtextures * sizeof(texture_t)); - for (i = 0;i < count;i++, in++, out++) + for (i = 0;i < count;i++, out++) { - } -*/ -} - -static void Mod_Q2BSP_LoadLighting(lump_t *l) -{ -/* - d_t *in; - m_t *out; - int i, count; - - in = (void *)(mod_base + l->fileofs); - if (l->filelen % sizeof(*in)) - Host_Error("Mod_Q2BSP_LoadLighting: funny lump size in %s",loadmodel->name); - count = l->filelen / sizeof(*in); - out = Mem_Alloc(loadmodel->mempool, count * sizeof(*out)); - - loadmodel-> = out; - loadmodel->num = count; - - for (i = 0;i < count;i++, in++, out++) + int j, k; + for (k = 0;k < 2;k++) + for (j = 0;j < 4;j++) + out->vecs[k][j] = MSG_ReadLittleFloat(sb); + + out->q2flags = MSG_ReadLittleLong(sb); + out->q2value = MSG_ReadLittleLong(sb); + MSG_ReadBytes(sb, 32, (unsigned char*)out->q2texture); + out->q2texture[31] = 0; // make absolutely sure it is terminated + out->q2nexttexinfo = MSG_ReadLittleLong(sb); + + // find an existing match for the texture if possible + dpsnprintf(filename, sizeof(filename), "textures/%s.wal", out->q2texture); + for (j = 0;j < loadmodel->num_texturesperskin;j++) + if (!strcmp(filename, loadmodel->data_textures[j].name) + && out->q2flags == loadmodel->data_textures[j].q2flags + && out->q2value == loadmodel->data_textures[j].q2value) + break; + // if we don't find the texture, store the new texture + if (j == loadmodel->num_texturesperskin) + { + if (loadmodel->num_texturesperskin < maxtextures) + { + texture_t *tx = loadmodel->data_textures + j; + int q2flags = out->q2flags; + unsigned char *walfile = NULL; + fs_offset_t walfilesize = 0; + Mod_LoadTextureFromQ3Shader(loadmodel->mempool, loadmodel->name, tx, filename, true, true, TEXF_ALPHA | TEXF_MIPMAP | TEXF_ISWORLD | TEXF_PICMIP | TEXF_COMPRESS, MATERIALFLAG_WALL); + // now read the .wal file to get metadata (even if a .tga was overriding it, we still need the wal data) + walfile = FS_LoadFile(filename, tempmempool, true, &walfilesize); + if (walfile) + { + int w, h; + LoadWAL_GetMetadata(walfile, (int)walfilesize, &w, &h, NULL, NULL, &tx->q2contents, NULL); + tx->width = w; + tx->height = h; + Mem_Free(walfile); + } + else + { + tx->width = 16; + tx->height = 16; + } + tx->q2flags = out->q2flags; + tx->q2value = out->q2value; + // also modify the texture to have the correct contents and such based on flags + // note that we create multiple texture_t structures if q2flags differs + if (q2flags & Q2SURF_LIGHT) + { + // doesn't mean anything to us + } + if (q2flags & Q2SURF_SLICK) + { + // would be nice to support... + } + if (q2flags & Q2SURF_SKY) + { + // sky is a rather specific thing + q2flags &= ~Q2SURF_NODRAW; // quake2 had a slightly different meaning than we have in mind here... + tx->basematerialflags = MATERIALFLAG_SKY; + tx->supercontents = SUPERCONTENTS_SKY | SUPERCONTENTS_NODROP | SUPERCONTENTS_OPAQUE; + tx->surfaceflags = Q3SURFACEFLAG_SKY | Q3SURFACEFLAG_NOIMPACT | Q3SURFACEFLAG_NOMARKS | Q3SURFACEFLAG_NODLIGHT | Q3SURFACEFLAG_NOLIGHTMAP; + } + if (q2flags & Q2SURF_WARP) + { + // we use a scroll instead of a warp + tx->basematerialflags |= MATERIALFLAG_WATERSCROLL | MATERIALFLAG_FULLBRIGHT; + // if it's also transparent, we can enable the WATERSHADER + // but we do not set the WATERALPHA flag because we don't + // want to honor r_wateralpha in q2bsp + // (it would go against the artistic intent) + if (q2flags & (Q2SURF_TRANS33 | Q2SURF_TRANS66)) + tx->basematerialflags |= MATERIALFLAG_WATERSHADER; + } + if (q2flags & Q2SURF_TRANS33) + { + tx->basematerialflags |= MATERIALFLAG_ALPHA | MATERIALFLAG_BLENDED; + tx->basealpha = 1.0f / 3.0f; + tx->supercontents &= ~SUPERCONTENTS_OPAQUE; + if (tx->q2contents & Q2CONTENTS_SOLID) + tx->q2contents = (tx->q2contents & ~Q2CONTENTS_SOLID) | Q2CONTENTS_WINDOW; + } + if (q2flags & Q2SURF_TRANS66) + { + tx->basematerialflags |= MATERIALFLAG_ALPHA | MATERIALFLAG_BLENDED; + tx->basealpha = 2.0f / 3.0f; + tx->supercontents &= ~SUPERCONTENTS_OPAQUE; + if (tx->q2contents & Q2CONTENTS_SOLID) + tx->q2contents = (tx->q2contents & ~Q2CONTENTS_SOLID) | Q2CONTENTS_WINDOW; + } + if ((q2flags & Q2SURF_FLOWING) && tx->materialshaderpass != NULL) + { + tx->materialshaderpass->tcmods[0].tcmod = Q3TCMOD_SCROLL; + if (q2flags & Q2SURF_WARP) + tx->materialshaderpass->tcmods[0].parms[0] = -0.5f; + else + tx->materialshaderpass->tcmods[0].parms[0] = -1.6f; + tx->materialshaderpass->tcmods[0].parms[1] = 0.0f; + } + if (q2flags & Q2SURF_ALPHATEST) + { + // KMQUAKE2 and other modded engines added this flag for lit alpha tested surfaces + tx->basematerialflags |= MATERIALFLAG_ALPHATEST | MATERIALFLAG_NOSHADOW; + } + else if (q2flags & (Q2SURF_TRANS33 | Q2SURF_TRANS66 | Q2SURF_WARP)) + { + if (!mod_q2bsp_littransparentsurfaces.integer) + tx->basematerialflags |= MATERIALFLAG_FULLBRIGHT; + } + if (q2flags & Q2SURF_NODRAW) + { + tx->basematerialflags = MATERIALFLAG_NODRAW | MATERIALFLAG_NOSHADOW; + } + if (tx->q2contents & (Q2CONTENTS_TRANSLUCENT | Q2CONTENTS_MONSTERCLIP | Q2CONTENTS_PLAYERCLIP)) + tx->q2contents |= Q2CONTENTS_DETAIL; + if (!(tx->q2contents & (Q2CONTENTS_SOLID | Q2CONTENTS_WINDOW | Q2CONTENTS_AUX | Q2CONTENTS_LAVA | Q2CONTENTS_SLIME | Q2CONTENTS_WATER | Q2CONTENTS_MIST | Q2CONTENTS_PLAYERCLIP | Q2CONTENTS_MONSTERCLIP | Q2CONTENTS_MIST))) + tx->q2contents |= Q2CONTENTS_SOLID; + if (tx->q2flags & (Q2SURF_HINT | Q2SURF_SKIP)) + tx->q2contents = 0; + tx->supercontents = Mod_Q2BSP_SuperContentsFromNativeContents(tx->q2contents); + // set the current values to the base values + tx->currentframe = tx; + tx->currentskinframe = tx->materialshaderpass != NULL ? tx->materialshaderpass->skinframes[0] : NULL; + tx->currentmaterialflags = tx->basematerialflags; + loadmodel->num_texturesperskin++; + loadmodel->num_textures = loadmodel->num_texturesperskin; + } + else + { + Con_Printf("Mod_Q2BSP_LoadTexinfo: max textures reached (%i)\n", maxtextures); + j = 0; // use first texture and give up + } + } + // store the index we found for this texture + out->textureindex = j; + } + + // realloc the textures array now that we know how many we actually need + loadmodel->data_textures = (texture_t*)Mem_Realloc(loadmodel->mempool, loadmodel->data_textures, loadmodel->num_texturesperskin * sizeof(texture_t)); + + // now assemble the texture chains + // if we encounter the textures out of order, the later ones won't mark the earlier ones in a sequence, so the earlier + for (i = 0, out = loadmodel->brushq1.texinfo;i < count;i++, out++) { + int j, k; + texture_t *t = loadmodel->data_textures + out->textureindex; + t->currentframe = t; // fix the reallocated pointer + + // if this is not animated, skip it + // if this is already processed, skip it (part of an existing sequence) + if (out->q2nexttexinfo == 0 || t->animated) + continue; + + // store the array of frames to use + t->animated = 2; // q2bsp animation + t->anim_total[0] = 0; + t->anim_total[1] = 0; + // gather up to 10 frames (we don't support more) + for (j = i;j >= 0 && t->anim_total[0] < (int)(sizeof(t->anim_frames[0])/sizeof(t->anim_frames[0][0]));j = loadmodel->brushq1.texinfo[j].q2nexttexinfo) + { + // detect looping and stop there + if (t->anim_total[0] && loadmodel->brushq1.texinfo[j].textureindex == out->textureindex) + break; + t->anim_frames[0][t->anim_total[0]++] = &loadmodel->data_textures[loadmodel->brushq1.texinfo[j].textureindex]; + } + // we could look for the +a sequence here if this is the +0 sequence, + // but it seems that quake2 did not implement that (even though the + // files exist in the baseq2 content) + + // write the frame sequence to all the textures involved (just like + // in the q1bsp loader) + // + // note that this can overwrite the rest of the sequence - so if the + // start of a sequence is found later than the other parts of the + // sequence, it will go back and rewrite them correctly. + for (k = 0;k < t->anim_total[0];k++) + { + texture_t *txk = t->anim_frames[0][k]; + txk->animated = t->animated; + txk->anim_total[0] = t->anim_total[0]; + for (l = 0;l < t->anim_total[0];l++) + txk->anim_frames[0][l] = t->anim_frames[0][l]; + } } -*/ } -static void Mod_Q2BSP_LoadLeafs(lump_t *l) +static void Mod_Q2BSP_LoadLighting(sizebuf_t *sb) { -/* - d_t *in; - m_t *out; - int i, count; + // LordHavoc: this fits exactly the same format that we use in .lit files + loadmodel->brushq1.lightdata = (unsigned char *)Mem_Alloc(loadmodel->mempool, sb->cursize); + MSG_ReadBytes(sb, sb->cursize, loadmodel->brushq1.lightdata); +} - in = (void *)(mod_base + l->fileofs); - if (l->filelen % sizeof(*in)) +static void Mod_Q2BSP_LoadLeafs(sizebuf_t *sb) +{ + mleaf_t *out; + int i, j, count, firstmarksurface, nummarksurfaces, firstmarkbrush, nummarkbrushes; + int structsize = 28; + + if (sb->cursize % structsize) Host_Error("Mod_Q2BSP_LoadLeafs: funny lump size in %s",loadmodel->name); - count = l->filelen / sizeof(*in); - out = Mem_Alloc(loadmodel->mempool, count * sizeof(*out)); + count = sb->cursize / structsize; + out = (mleaf_t *)Mem_Alloc(loadmodel->mempool, count*sizeof(*out)); - loadmodel-> = out; - loadmodel->num = count; + loadmodel->brush.data_leafs = out; + loadmodel->brush.num_leafs = count; - for (i = 0;i < count;i++, in++, out++) - { - } -*/ -} + // FIXME: this function could really benefit from some error checking + for ( i=0 ; icontents = MSG_ReadLittleLong(sb); + out->clusterindex = MSG_ReadLittleShort(sb); + out->areaindex = MSG_ReadLittleShort(sb); + out->mins[0] = MSG_ReadLittleShort(sb); + out->mins[1] = MSG_ReadLittleShort(sb); + out->mins[2] = MSG_ReadLittleShort(sb); + out->maxs[0] = MSG_ReadLittleShort(sb); + out->maxs[1] = MSG_ReadLittleShort(sb); + out->maxs[2] = MSG_ReadLittleShort(sb); + + firstmarksurface = (unsigned short)MSG_ReadLittleShort(sb); + nummarksurfaces = (unsigned short)MSG_ReadLittleShort(sb); + firstmarkbrush = (unsigned short)MSG_ReadLittleShort(sb); + nummarkbrushes = (unsigned short)MSG_ReadLittleShort(sb); -static void Mod_Q2BSP_LoadLeafFaces(lump_t *l) -{ -/* - d_t *in; - m_t *out; - int i, count; + for (j = 0;j < 4;j++) + out->ambient_sound_level[j] = 0; - in = (void *)(mod_base + l->fileofs); - if (l->filelen % sizeof(*in)) - Host_Error("Mod_Q2BSP_LoadLeafFaces: funny lump size in %s",loadmodel->name); - count = l->filelen / sizeof(*in); - out = Mem_Alloc(loadmodel->mempool, count * sizeof(*out)); + if (out->clusterindex >= loadmodel->brush.num_pvsclusters) + { + Con_Print("Mod_Q2BSP_LoadLeafs: invalid clusterindex\n"); + out->clusterindex = -1; + } - loadmodel-> = out; - loadmodel->num = count; + if (firstmarksurface >= 0 && firstmarksurface + nummarksurfaces <= loadmodel->brush.num_leafsurfaces) + { + out->firstleafsurface = loadmodel->brush.data_leafsurfaces + firstmarksurface; + out->numleafsurfaces = nummarksurfaces; + } + else + { + Con_Printf("Mod_Q2BSP_LoadLeafs: invalid leafsurface range %i:%i outside range %i:%i\n", firstmarksurface, firstmarksurface+nummarksurfaces, 0, loadmodel->brush.num_leafsurfaces); + out->firstleafsurface = NULL; + out->numleafsurfaces = 0; + } - for (i = 0;i < count;i++, in++, out++) - { + if (firstmarkbrush >= 0 && firstmarkbrush + nummarkbrushes <= loadmodel->brush.num_leafbrushes) + { + out->firstleafbrush = loadmodel->brush.data_leafbrushes + firstmarkbrush; + out->numleafbrushes = nummarkbrushes; + } + else + { + Con_Printf("Mod_Q2BSP_LoadLeafs: invalid leafbrush range %i:%i outside range %i:%i\n", firstmarkbrush, firstmarkbrush+nummarkbrushes, 0, loadmodel->brush.num_leafbrushes); + out->firstleafbrush = NULL; + out->numleafbrushes = 0; + } } -*/ } -static void Mod_Q2BSP_LoadLeafBrushes(lump_t *l) +static void Mod_Q2BSP_LoadLeafBrushes(sizebuf_t *sb) { -/* - d_t *in; - m_t *out; - int i, count; + int i, j; + int structsize = 2; - in = (void *)(mod_base + l->fileofs); - if (l->filelen % sizeof(*in)) + if (sb->cursize % structsize) Host_Error("Mod_Q2BSP_LoadLeafBrushes: funny lump size in %s",loadmodel->name); - count = l->filelen / sizeof(*in); - out = Mem_Alloc(loadmodel->mempool, count * sizeof(*out)); + loadmodel->brush.num_leafbrushes = sb->cursize / structsize; + loadmodel->brush.data_leafbrushes = (int *)Mem_Alloc(loadmodel->mempool, loadmodel->brush.num_leafbrushes * sizeof(int)); - loadmodel-> = out; - loadmodel->num = count; - - for (i = 0;i < count;i++, in++, out++) + for (i = 0;i < loadmodel->brush.num_leafbrushes;i++) { + j = (unsigned short) MSG_ReadLittleShort(sb); + if (j >= loadmodel->brush.num_brushes) + Host_Error("Mod_Q1BSP_LoadLeafBrushes: bad brush number"); + loadmodel->brush.data_leafbrushes[i] = j; } -*/ } -static void Mod_Q2BSP_LoadEdges(lump_t *l) +static void Mod_Q2BSP_LoadBrushSides(sizebuf_t *sb) { -/* - d_t *in; - m_t *out; - int i, count; + q3mbrushside_t *out; + int i, n, count; + int structsize = 4; - in = (void *)(mod_base + l->fileofs); - if (l->filelen % sizeof(*in)) - Host_Error("Mod_Q2BSP_LoadEdges: funny lump size in %s",loadmodel->name); - count = l->filelen / sizeof(*in); - out = Mem_Alloc(loadmodel->mempool, count * sizeof(*out)); + if (sb->cursize % structsize) + Host_Error("Mod_Q2BSP_LoadBrushSides: funny lump size in %s",loadmodel->name); + count = sb->cursize / structsize; + out = (q3mbrushside_t *)Mem_Alloc(loadmodel->mempool, count * sizeof(*out)); - loadmodel-> = out; - loadmodel->num = count; + loadmodel->brush.data_brushsides = out; + loadmodel->brush.num_brushsides = count; - for (i = 0;i < count;i++, in++, out++) + for (i = 0;i < count;i++, out++) { + n = (unsigned short)MSG_ReadLittleShort(sb); + if (n < 0 || n >= loadmodel->brush.num_planes) + Host_Error("Mod_Q2BSP_LoadBrushSides: invalid planeindex %i (%i planes)", n, loadmodel->brush.num_planes); + out->plane = loadmodel->brush.data_planes + n; + n = MSG_ReadLittleShort(sb); + if (n >= 0) + { + if (n >= loadmodel->brushq1.numtexinfo) + Host_Error("Mod_Q2BSP_LoadBrushSides: invalid texinfo index %i (%i texinfos)", n, loadmodel->brushq1.numtexinfo); + out->texture = loadmodel->data_textures + loadmodel->brushq1.texinfo[n].textureindex; + } + else + { + //Con_Printf("Mod_Q2BSP_LoadBrushSides: brushside %i has texinfo index %i < 0, changing to generic texture!\n", i, n); + out->texture = &mod_q1bsp_texture_solid; + } } -*/ } -static void Mod_Q2BSP_LoadSurfEdges(lump_t *l) +static void Mod_Q2BSP_LoadBrushes(sizebuf_t *sb) { -/* - d_t *in; - m_t *out; - int i, count; + q3mbrush_t *out; + int i, j, firstside, numsides, contents, count, maxplanes, q3surfaceflags, supercontents; + colplanef_t *planes; + int structsize = 12; + qboolean brushmissingtextures; + int numbrushesmissingtextures = 0; + int numcreatedtextures = 0; - in = (void *)(mod_base + l->fileofs); - if (l->filelen % sizeof(*in)) - Host_Error("Mod_Q2BSP_LoadSurfEdges: funny lump size in %s",loadmodel->name); - count = l->filelen / sizeof(*in); - out = Mem_Alloc(loadmodel->mempool, count * sizeof(*out)); + if (sb->cursize % structsize) + Host_Error("Mod_Q2BSP_LoadBrushes: funny lump size in %s",loadmodel->name); + count = sb->cursize / structsize; + out = (q3mbrush_t *)Mem_Alloc(loadmodel->mempool, count * sizeof(*out)); - loadmodel-> = out; - loadmodel->num = count; + loadmodel->brush.data_brushes = out; + loadmodel->brush.num_brushes = count; - for (i = 0;i < count;i++, in++, out++) + maxplanes = 0; + planes = NULL; + + for (i = 0; i < count; i++, out++) { + firstside = MSG_ReadLittleLong(sb); + numsides = MSG_ReadLittleLong(sb); + contents = MSG_ReadLittleLong(sb); + if (firstside < 0 || firstside + numsides > loadmodel->brush.num_brushsides) + Host_Error("Mod_Q3BSP_LoadBrushes: invalid brushside range %i : %i (%i brushsides)", firstside, firstside + numsides, loadmodel->brush.num_brushsides); + + out->firstbrushside = loadmodel->brush.data_brushsides + firstside; + out->numbrushsides = numsides; + // convert the contents to our values + supercontents = Mod_Q2BSP_SuperContentsFromNativeContents(contents); + + // problem: q2bsp brushes have contents but not a texture + // problem: q2bsp brushsides *may* have a texture or may not + // problem: all brushsides and brushes must have a texture for trace_hittexture functionality to work, and the collision code is engineered around this assumption + // solution: nasty hacks + brushmissingtextures = false; + out->texture = NULL; + for (j = 0; j < out->numbrushsides; j++) + { + if (out->firstbrushside[j].texture == &mod_q1bsp_texture_solid) + brushmissingtextures = true; + else + { + // if we can find a matching texture on a brush side we can use it instead of creating one + if (out->firstbrushside[j].texture->supercontents == supercontents) + out->texture = out->firstbrushside[j].texture; + } + } + if (brushmissingtextures || out->texture == NULL) + { + numbrushesmissingtextures++; + // if we didn't find any appropriate texture (matching contents), we'll have to create one + // we could search earlier ones for a matching one but that can be slow + if (out->texture == NULL) + { + texture_t *validtexture; + validtexture = (texture_t *)Mem_Alloc(loadmodel->mempool, sizeof(texture_t)); + dpsnprintf(validtexture->name, sizeof(validtexture->name), "brushcollision%i", numcreatedtextures); + validtexture->surfaceflags = 0; + validtexture->supercontents = supercontents; + numcreatedtextures++; + out->texture = validtexture; + } + // out->texture now contains a texture with appropriate contents, copy onto any missing sides + for (j = 0; j < out->numbrushsides; j++) + if (out->firstbrushside[j].texture == &mod_q1bsp_texture_solid) + out->firstbrushside[j].texture = out->texture; + } + + // make a colbrush from the brush + q3surfaceflags = 0; + // make a list of mplane_t structs to construct a colbrush from + if (maxplanes < out->numbrushsides) + { + maxplanes = out->numbrushsides; + if (planes) + Mem_Free(planes); + planes = (colplanef_t *)Mem_Alloc(tempmempool, sizeof(colplanef_t) * maxplanes); + } + 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; + } + 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); + if (numcreatedtextures) + Con_DPrintf("Mod_Q2BSP_LoadBrushes: %i brushes own sides that lack textures or have differing contents from the brush, %i textures have been created to describe these contents.\n", numbrushesmissingtextures, numcreatedtextures); } -static void Mod_Q2BSP_LoadBrushes(lump_t *l) +static void Mod_Q2BSP_LoadPOP(sizebuf_t *sb) { -/* - d_t *in; - m_t *out; - int i, count; - - in = (void *)(mod_base + l->fileofs); - if (l->filelen % sizeof(*in)) - Host_Error("Mod_Q2BSP_LoadBrushes: funny lump size in %s",loadmodel->name); - count = l->filelen / sizeof(*in); - out = Mem_Alloc(loadmodel->mempool, count * sizeof(*out)); + // this is probably a "proof of purchase" lump of some sort, it seems to be 0 size in most bsp files (but not q2dm1.bsp for instance) + sb->readcount = sb->cursize; +} - loadmodel-> = out; - loadmodel->num = count; +static void Mod_Q2BSP_LoadAreas(sizebuf_t *sb) +{ + // we currently don't use areas, they represent closable doors as vis blockers + sb->readcount = sb->cursize; +} - for (i = 0;i < count;i++, in++, out++) - { - } -*/ +static void Mod_Q2BSP_LoadAreaPortals(sizebuf_t *sb) +{ + // we currently don't use areas, they represent closable doors as vis blockers + sb->readcount = sb->cursize; } -static void Mod_Q2BSP_LoadBrushSides(lump_t *l) +static void Mod_Q2BSP_LoadSubmodels(sizebuf_t *sb) { -/* - d_t *in; - m_t *out; - int i, count; + mmodel_t *out; + int i, count; + int structsize = 48; - in = (void *)(mod_base + l->fileofs); - if (l->filelen % sizeof(*in)) - Host_Error("Mod_Q2BSP_LoadBrushSides: funny lump size in %s",loadmodel->name); - count = l->filelen / sizeof(*in); - out = Mem_Alloc(loadmodel->mempool, count * sizeof(*out)); + if (sb->cursize % structsize) + Host_Error ("Mod_Q2BSP_LoadSubmodels: funny lump size in %s", loadmodel->name); - loadmodel-> = out; - loadmodel->num = count; + count = sb->cursize / structsize; + out = (mmodel_t *)Mem_Alloc (loadmodel->mempool, count*sizeof(*out)); - for (i = 0;i < count;i++, in++, out++) + loadmodel->brushq1.submodels = out; + loadmodel->brush.numsubmodels = count; + + // this is identical to the q1 submodel structure except for having 1 hull + for (i = 0; i < count; i++, out++) { + // spread out the mins / maxs by a pixel + out->mins[0] = MSG_ReadLittleFloat(sb) - 1; + out->mins[1] = MSG_ReadLittleFloat(sb) - 1; + out->mins[2] = MSG_ReadLittleFloat(sb) - 1; + out->maxs[0] = MSG_ReadLittleFloat(sb) + 1; + out->maxs[1] = MSG_ReadLittleFloat(sb) + 1; + out->maxs[2] = MSG_ReadLittleFloat(sb) + 1; + out->origin[0] = MSG_ReadLittleFloat(sb); + out->origin[1] = MSG_ReadLittleFloat(sb); + out->origin[2] = MSG_ReadLittleFloat(sb); + out->headnode[0] = MSG_ReadLittleLong(sb); + out->firstface = MSG_ReadLittleLong(sb); + out->numfaces = MSG_ReadLittleLong(sb); } -*/ } -static void Mod_Q2BSP_LoadAreas(lump_t *l) +static void Mod_Q2BSP_FindSubmodelBrushRange_r(dp_model_t *mod, mnode_t *node, int *first, int *last) { -/* - d_t *in; - m_t *out; - int i, count; + int i; + mleaf_t *leaf; + while (node->plane) + { + Mod_Q2BSP_FindSubmodelBrushRange_r(mod, node->children[0], first, last); + node = node->children[1]; + } + leaf = (mleaf_t*)node; + for (i = 0;i < leaf->numleafbrushes;i++) + { + int brushnum = leaf->firstleafbrush[i]; + if (*first > brushnum) + *first = brushnum; + if (*last < brushnum) + *last = brushnum; + } +} - in = (void *)(mod_base + l->fileofs); - if (l->filelen % sizeof(*in)) - Host_Error("Mod_Q2BSP_LoadAreas: funny lump size in %s",loadmodel->name); - count = l->filelen / sizeof(*in); - out = Mem_Alloc(loadmodel->mempool, count * sizeof(*out)); +static void Mod_Q2BSP_Load(dp_model_t *mod, void *buffer, void *bufferend) +{ + int i, j, k; + sizebuf_t lumpsb[Q2HEADER_LUMPS]; + mmodel_t *bm; + float dist, modelyawradius, modelradius; + msurface_t *surface; + int totalstylesurfaces, totalstyles, stylecounts[256], remapstyles[256]; + model_brush_lightstyleinfo_t styleinfo[256]; + unsigned char *datapointer; + sizebuf_t sb; - loadmodel-> = out; - loadmodel->num = count; + MSG_InitReadBuffer(&sb, (unsigned char *)buffer, (unsigned char *)bufferend - (unsigned char *)buffer); - for (i = 0;i < count;i++, in++, out++) + mod->type = mod_brushq2; + + mod->brush.ishlbsp = false; + mod->brush.isbsp2rmqe = false; + mod->brush.isbsp2 = false; + mod->brush.isq2bsp = true; // q1bsp loaders mostly work but we need a few tweaks + mod->brush.isq3bsp = false; + mod->brush.skymasking = true; + mod->modeldatatypestring = "Q2BSP"; + + i = MSG_ReadLittleLong(&sb); + if (i != Q2BSPMAGIC) + Host_Error("Mod_Q2BSP_Load: %s has wrong version number (%i, should be %i)", mod->name, i, Q2BSPVERSION); + + i = MSG_ReadLittleLong(&sb); + if (i != Q2BSPVERSION) + Host_Error("Mod_Q2BSP_Load: %s has wrong version number (%i, should be %i)", mod->name, i, Q2BSPVERSION); + +// read lumps + for (i = 0; i < Q2HEADER_LUMPS; i++) { + int offset = MSG_ReadLittleLong(&sb); + int size = MSG_ReadLittleLong(&sb); + if (offset < 0 || offset + size > sb.cursize) + Host_Error("Mod_Q2BSP_Load: %s has invalid lump %i (offset %i, size %i, file size %i)\n", mod->name, i, offset, size, (int)sb.cursize); + MSG_InitReadBuffer(&lumpsb[i], sb.data + offset, size); } -*/ -} -static void Mod_Q2BSP_LoadAreaPortals(lump_t *l) -{ -/* - d_t *in; - m_t *out; - int i, count; + mod->soundfromcenter = true; + mod->TracePoint = Mod_CollisionBIH_TracePoint; + mod->TraceLine = Mod_CollisionBIH_TraceLine; + mod->TraceBox = Mod_CollisionBIH_TraceBox; + mod->TraceBrush = Mod_CollisionBIH_TraceBrush; + mod->PointSuperContents = Mod_CollisionBIH_PointSuperContents; + mod->TraceLineAgainstSurfaces = Mod_CollisionBIH_TraceLine; + mod->brush.TraceLineOfSight = Mod_Q3BSP_TraceLineOfSight; + mod->brush.SuperContentsFromNativeContents = Mod_Q2BSP_SuperContentsFromNativeContents; + mod->brush.NativeContentsFromSuperContents = Mod_Q2BSP_NativeContentsFromSuperContents; + mod->brush.GetPVS = Mod_Q1BSP_GetPVS; + mod->brush.FatPVS = Mod_Q1BSP_FatPVS; + mod->brush.BoxTouchingPVS = Mod_Q1BSP_BoxTouchingPVS; + mod->brush.BoxTouchingLeafPVS = Mod_Q1BSP_BoxTouchingLeafPVS; + mod->brush.BoxTouchingVisibleLeafs = Mod_Q1BSP_BoxTouchingVisibleLeafs; + mod->brush.FindBoxClusters = Mod_Q1BSP_FindBoxClusters; + mod->brush.LightPoint = Mod_Q1BSP_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->DrawLight = R_Q1BSP_DrawLight; + +// load into heap + + mod->brush.qw_md4sum = 0; + mod->brush.qw_md4sum2 = 0; + for (i = 0;i < Q2HEADER_LUMPS;i++) + { + int temp; + if (i == Q2LUMP_ENTITIES) + continue; + temp = Com_BlockChecksum(lumpsb[i].data, lumpsb[i].cursize); + mod->brush.qw_md4sum ^= LittleLong(temp); + if (i == Q2LUMP_VISIBILITY || i == Q2LUMP_LEAFS || i == Q2LUMP_NODES) + continue; + mod->brush.qw_md4sum2 ^= LittleLong(temp); + } + + // many of these functions are identical to Q1 loaders, so we use those where possible + Mod_Q1BSP_LoadEntities(&lumpsb[Q2LUMP_ENTITIES]); + Mod_Q1BSP_LoadVertexes(&lumpsb[Q2LUMP_VERTEXES]); + Mod_Q1BSP_LoadEdges(&lumpsb[Q2LUMP_EDGES]); + Mod_Q1BSP_LoadSurfedges(&lumpsb[Q2LUMP_SURFEDGES]); + Mod_Q2BSP_LoadLighting(&lumpsb[Q2LUMP_LIGHTING]); + Mod_Q1BSP_LoadPlanes(&lumpsb[Q2LUMP_PLANES]); + Mod_Q2BSP_LoadTexinfo(&lumpsb[Q2LUMP_TEXINFO]); + Mod_Q2BSP_LoadBrushSides(&lumpsb[Q2LUMP_BRUSHSIDES]); + Mod_Q2BSP_LoadBrushes(&lumpsb[Q2LUMP_BRUSHES]); + Mod_Q1BSP_LoadFaces(&lumpsb[Q2LUMP_FACES]); + Mod_Q1BSP_LoadLeaffaces(&lumpsb[Q2LUMP_LEAFFACES]); + Mod_Q2BSP_LoadLeafBrushes(&lumpsb[Q2LUMP_LEAFBRUSHES]); + Mod_Q2BSP_LoadVisibility(&lumpsb[Q2LUMP_VISIBILITY]); + Mod_Q2BSP_LoadPOP(&lumpsb[Q2LUMP_POP]); + Mod_Q2BSP_LoadAreas(&lumpsb[Q2LUMP_AREAS]); + Mod_Q2BSP_LoadAreaPortals(&lumpsb[Q2LUMP_AREAPORTALS]); + Mod_Q2BSP_LoadLeafs(&lumpsb[Q2LUMP_LEAFS]); + Mod_Q2BSP_LoadNodes(&lumpsb[Q2LUMP_NODES]); + Mod_Q2BSP_LoadSubmodels(&lumpsb[Q2LUMP_MODELS]); + + for (i = 0; i < Q2HEADER_LUMPS; i++) + if (lumpsb[i].readcount != lumpsb[i].cursize) + Host_Error("Lump %i incorrectly loaded (readcount %i, size %i)\n", i, lumpsb[i].readcount, lumpsb[i].cursize); + + // we don't actually set MATERIALFLAG_WATERALPHA on anything, so this + // doesn't enable the cvar, just indicates that transparent water is OK + loadmodel->brush.supportwateralpha = true; + + // we don't need the compressed pvs data anymore + if (mod->brushq1.data_compressedpvs) + Mem_Free(mod->brushq1.data_compressedpvs); + mod->brushq1.data_compressedpvs = NULL; + mod->brushq1.num_compressedpvs = 0; + + // the MakePortals code works fine on the q2bsp data as well + if (mod_bsp_portalize.integer) + Mod_Q1BSP_MakePortals(); - in = (void *)(mod_base + l->fileofs); - if (l->filelen % sizeof(*in)) - Host_Error("Mod_Q2BSP_LoadAreaPortals: funny lump size in %s",loadmodel->name); - count = l->filelen / sizeof(*in); - out = Mem_Alloc(loadmodel->mempool, count * sizeof(*out)); + mod->numframes = 0; // q2bsp animations are kind of special, frame is unbounded... + mod->numskins = 1; - loadmodel-> = out; - loadmodel->num = count; + if (loadmodel->brush.numsubmodels) + loadmodel->brush.submodels = (dp_model_t **)Mem_Alloc(loadmodel->mempool, loadmodel->brush.numsubmodels * sizeof(dp_model_t *)); - for (i = 0;i < count;i++, in++, out++) + 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 *)); + // set up the world model, then on each submodel copy from the world model + // and set up the submodel with the respective model info. + mod = loadmodel; + for (i = 0;i < loadmodel->brush.numsubmodels;i++) + { + mnode_t *rootnode = NULL; + int firstbrush = loadmodel->brush.num_brushes, lastbrush = 0; + if (i > 0) + { + char name[10]; + // duplicate the basic information + 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; + if (loadmodel->brush.submodels) + loadmodel->brush.submodels[i] = mod; -static void Mod_Q2BSP_LoadModels(lump_t *l) -{ -/* - d_t *in; - m_t *out; - int i, count; + bm = &mod->brushq1.submodels[i]; - in = (void *)(mod_base + l->fileofs); - if (l->filelen % sizeof(*in)) - Host_Error("Mod_Q2BSP_LoadModels: funny lump size in %s",loadmodel->name); - count = l->filelen / sizeof(*in); - out = Mem_Alloc(loadmodel->mempool, count * sizeof(*out)); + // we store the headnode (there's only one in Q2BSP) as if it were the first hull + mod->brushq1.hulls[0].firstclipnode = bm->headnode[0]; - loadmodel-> = out; - loadmodel->num = count; + mod->firstmodelsurface = bm->firstface; + mod->nummodelsurfaces = bm->numfaces; - for (i = 0;i < count;i++, in++, out++) - { - } -*/ -} + // set node/leaf parents for this submodel + // note: if the root of this submodel is a leaf (headnode[0] < 0) then there is nothing to do... + // (this happens in base3.bsp) + if (bm->headnode[0] >= 0) + rootnode = mod->brush.data_nodes + bm->headnode[0]; + else + rootnode = (mnode_t*)(mod->brush.data_leafs + -1 - bm->headnode[0]); + Mod_Q1BSP_LoadNodes_RecursiveSetParent(rootnode, NULL); -void static Mod_Q2BSP_Load(dp_model_t *mod, void *buffer, void *bufferend) -{ - int i; - q2dheader_t *header; + // make the model surface list (used by shadowing/lighting) + mod->sortedmodelsurfaces = (int *)datapointer;datapointer += mod->nummodelsurfaces * sizeof(int); + Mod_Q2BSP_FindSubmodelBrushRange_r(mod, rootnode, &firstbrush, &lastbrush); + if (firstbrush <= lastbrush) + { + mod->firstmodelbrush = firstbrush; + mod->nummodelbrushes = lastbrush + 1 - firstbrush; + } + else + { + mod->firstmodelbrush = 0; + mod->nummodelbrushes = 0; + } + Mod_MakeSortedSurfaces(mod); - Host_Error("Mod_Q2BSP_Load: not yet implemented"); + 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; - mod->modeldatatypestring = "Q2BSP"; + // this gets altered below if sky or water is used + mod->DrawSky = NULL; + mod->DrawAddWaterPlanes = NULL; - mod->type = mod_brushq2; + // 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) + { + for (j = 0, surface = &mod->data_surfaces[mod->firstmodelsurface];j < mod->nummodelsurfaces;j++, surface++) + if (surface->texture->basematerialflags & MATERIALFLAG_SKY) + break; + if (j < mod->nummodelsurfaces) + mod->DrawSky = R_Q1BSP_DrawSky; - header = (q2dheader_t *)buffer; + for (j = 0, surface = &mod->data_surfaces[mod->firstmodelsurface];j < mod->nummodelsurfaces;j++, surface++) + if (surface->texture->basematerialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION | MATERIALFLAG_REFLECTION | MATERIALFLAG_CAMERA)) + break; + if (j < mod->nummodelsurfaces) + mod->DrawAddWaterPlanes = R_Q1BSP_DrawAddWaterPlanes; - 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); + // build lightstyle update chains + // (used to rapidly mark lightmapupdateflags on many surfaces + // when d_lightstylevalue changes) + memset(stylecounts, 0, sizeof(stylecounts)); + for (k = 0;k < mod->nummodelsurfaces;k++) + { + surface = mod->data_surfaces + mod->firstmodelsurface + k; + for (j = 0;j < MAXLIGHTMAPS;j++) + stylecounts[surface->lightmapinfo->styles[j]]++; + } + mod->brushq1.num_lightstyles = 0; + for (k = 0;k < 255;k++) + { + if (stylecounts[k]) + { + styleinfo[mod->brushq1.num_lightstyles].style = k; + styleinfo[mod->brushq1.num_lightstyles].value = 0; + styleinfo[mod->brushq1.num_lightstyles].numsurfaces = 0; + styleinfo[mod->brushq1.num_lightstyles].surfacelist = (int *)datapointer;datapointer += stylecounts[k] * sizeof(int); + remapstyles[k] = mod->brushq1.num_lightstyles; + mod->brushq1.num_lightstyles++; + } + } + for (k = 0;k < mod->nummodelsurfaces;k++) + { + surface = mod->data_surfaces + mod->firstmodelsurface + k; + for (j = 0;j < MAXLIGHTMAPS;j++) + { + if (surface->lightmapinfo->styles[j] != 255) + { + int r = remapstyles[surface->lightmapinfo->styles[j]]; + styleinfo[r].surfacelist[styleinfo[r].numsurfaces++] = mod->firstmodelsurface + k; + } + } + } + mod->brushq1.data_lightstyleinfo = (model_brush_lightstyleinfo_t *)datapointer;datapointer += mod->brushq1.num_lightstyles * sizeof(model_brush_lightstyleinfo_t); + memcpy(mod->brushq1.data_lightstyleinfo, styleinfo, mod->brushq1.num_lightstyles * sizeof(model_brush_lightstyleinfo_t)); + } + else + { + Con_Printf("warning: empty submodel *%i in %s\n", i+1, loadmodel->name); + } + //mod->brushq1.num_visleafs = bm->visleafs; - mod_base = (unsigned char *)header; + // build a Bounding Interval Hierarchy for culling triangles in light rendering + Mod_MakeCollisionBIH(mod, false, &mod->collision_bih); - // swap all the lumps - for (i = 0;i < (int) sizeof(*header) / 4;i++) - ((int *)header)[i] = LittleLong(((int *)header)[i]); + // build a Bounding Interval Hierarchy for culling brushes in collision detection + Mod_MakeCollisionBIH(mod, true, &mod->render_bih); - mod->brush.qw_md4sum = 0; - mod->brush.qw_md4sum2 = 0; - for (i = 0;i < Q2HEADER_LUMPS;i++) - { - if (i == Q2LUMP_ENTITIES) - continue; - mod->brush.qw_md4sum ^= Com_BlockChecksum(mod_base + header->lumps[i].fileofs, header->lumps[i].filelen); - if (i == Q2LUMP_VISIBILITY || i == Q2LUMP_LEAFS || i == Q2LUMP_NODES) - continue; - mod->brush.qw_md4sum2 ^= Com_BlockChecksum(mod_base + header->lumps[i].fileofs, header->lumps[i].filelen); + // generate VBOs and other shared data before cloning submodels + if (i == 0) + Mod_BuildVBOs(); } + mod = loadmodel; + + Con_DPrintf("Stats for q2bsp model \"%s\": %i faces, %i nodes, %i leafs, %i clusters, %i clusterportals, mesh: %i vertices, %i triangles, %i surfaces\n", loadmodel->name, loadmodel->num_surfaces, loadmodel->brush.num_nodes, loadmodel->brush.num_leafs, mod->brush.num_pvsclusters, loadmodel->brush.num_portals, loadmodel->surfmesh.num_vertices, loadmodel->surfmesh.num_triangles, loadmodel->num_surfaces); +} - Mod_Q2BSP_LoadEntities(&header->lumps[Q2LUMP_ENTITIES]); - Mod_Q2BSP_LoadPlanes(&header->lumps[Q2LUMP_PLANES]); - Mod_Q2BSP_LoadVertices(&header->lumps[Q2LUMP_VERTEXES]); - Mod_Q2BSP_LoadVisibility(&header->lumps[Q2LUMP_VISIBILITY]); - Mod_Q2BSP_LoadNodes(&header->lumps[Q2LUMP_NODES]); - Mod_Q2BSP_LoadTexInfo(&header->lumps[Q2LUMP_TEXINFO]); - Mod_Q2BSP_LoadFaces(&header->lumps[Q2LUMP_FACES]); - Mod_Q2BSP_LoadLighting(&header->lumps[Q2LUMP_LIGHTING]); - Mod_Q2BSP_LoadLeafs(&header->lumps[Q2LUMP_LEAFS]); - Mod_Q2BSP_LoadLeafFaces(&header->lumps[Q2LUMP_LEAFFACES]); - Mod_Q2BSP_LoadLeafBrushes(&header->lumps[Q2LUMP_LEAFBRUSHES]); - Mod_Q2BSP_LoadEdges(&header->lumps[Q2LUMP_EDGES]); - Mod_Q2BSP_LoadSurfEdges(&header->lumps[Q2LUMP_SURFEDGES]); - Mod_Q2BSP_LoadBrushes(&header->lumps[Q2LUMP_BRUSHES]); - Mod_Q2BSP_LoadBrushSides(&header->lumps[Q2LUMP_BRUSHSIDES]); - Mod_Q2BSP_LoadAreas(&header->lumps[Q2LUMP_AREAS]); - Mod_Q2BSP_LoadAreaPortals(&header->lumps[Q2LUMP_AREAPORTALS]); - // LordHavoc: must go last because this makes the submodels - Mod_Q2BSP_LoadModels(&header->lumps[Q2LUMP_MODELS]); -} - -static int Mod_Q3BSP_SuperContentsFromNativeContents(dp_model_t *model, int nativecontents); -static int Mod_Q3BSP_NativeContentsFromSuperContents(dp_model_t *model, int supercontents); +static int Mod_Q3BSP_SuperContentsFromNativeContents(int nativecontents); +static int Mod_Q3BSP_NativeContentsFromSuperContents(int supercontents); static void Mod_Q3BSP_LoadEntities(lump_t *l) { @@ -4285,11 +5202,13 @@ static void Mod_Q3BSP_LoadEntities(lump_t *l) loadmodel->brush.entities[l->filelen] = 0; data = loadmodel->brush.entities; // some Q3 maps override the lightgrid_cellsize with a worldspawn key - if (data && COM_ParseToken_Simple(&data, false, false) && com_token[0] == '{') + // 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, true) && com_token[0] == '{') { while (1) { - if (!COM_ParseToken_Simple(&data, false, false)) + if (!COM_ParseToken_Simple(&data, false, false, true)) break; // error if (com_token[0] == '}') break; // end of worldspawn @@ -4299,16 +5218,37 @@ static void Mod_Q3BSP_LoadEntities(lump_t *l) strlcpy(key, com_token, sizeof(key)); while (key[strlen(key)-1] == ' ') // remove trailing spaces key[strlen(key)-1] = 0; - if (!COM_ParseToken_Simple(&data, false, false)) + if (!COM_ParseToken_Simple(&data, false, false, true)) 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; + } } } } @@ -4332,16 +5272,13 @@ static void Mod_Q3BSP_LoadTextures(lump_t *l) for (i = 0;i < count;i++) { - strlcpy (out[i].name, in[i].name, sizeof (out[i].name)); out[i].surfaceflags = LittleLong(in[i].surfaceflags); - out[i].supercontents = Mod_Q3BSP_SuperContentsFromNativeContents(loadmodel, LittleLong(in[i].contents)); + out[i].supercontents = Mod_Q3BSP_SuperContentsFromNativeContents(LittleLong(in[i].contents)); + Mod_LoadTextureFromQ3Shader(loadmodel->mempool, loadmodel->name, out + i, in[i].name, true, true, TEXF_MIPMAP | TEXF_ISWORLD | TEXF_PICMIP | TEXF_COMPRESS, MATERIALFLAG_WALL); + // restore the surfaceflags and supercontents + out[i].surfaceflags = LittleLong(in[i].surfaceflags); + out[i].supercontents = Mod_Q3BSP_SuperContentsFromNativeContents(LittleLong(in[i].contents)); } - - if (cls.state == ca_dedicated) - return; - - for (i = 0;i < count;i++, in++, out++) - 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) @@ -4429,7 +5366,7 @@ 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); @@ -4465,15 +5402,17 @@ 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); @@ -4539,10 +5478,43 @@ static void Mod_Q3BSP_LoadVertices(lump_t *l) loadmodel->brushq3.data_texcoordlightmap2f[i * 2 + 0] = LittleFloat(in->lightmap2f[0]); loadmodel->brushq3.data_texcoordlightmap2f[i * 2 + 1] = LittleFloat(in->lightmap2f[1]); // svector/tvector are calculated later in face loading - loadmodel->brushq3.data_color4f[i * 4 + 0] = in->color4ub[0] * (1.0f / 255.0f); - loadmodel->brushq3.data_color4f[i * 4 + 1] = in->color4ub[1] * (1.0f / 255.0f); - loadmodel->brushq3.data_color4f[i * 4 + 2] = in->color4ub[2] * (1.0f / 255.0f); + if(mod_q3bsp_sRGBlightmaps.integer) + { + // if lightmaps are sRGB, vertex colors are sRGB too, so we need to linearize them + // note: when this is in use, lightmap color 128 is no longer neutral, but "sRGB half power" is + // working like this may be odd, but matches q3map2 -gamma 2.2 + if(vid_sRGB.integer && vid_sRGB_fallback.integer && !vid.sRGB3D) + { + loadmodel->brushq3.data_color4f[i * 4 + 0] = in->color4ub[0] * (1.0f / 255.0f); + loadmodel->brushq3.data_color4f[i * 4 + 1] = in->color4ub[1] * (1.0f / 255.0f); + loadmodel->brushq3.data_color4f[i * 4 + 2] = in->color4ub[2] * (1.0f / 255.0f); + // we fix the brightness consistently via lightmapscale + } + else + { + loadmodel->brushq3.data_color4f[i * 4 + 0] = Image_LinearFloatFromsRGB(in->color4ub[0]); + loadmodel->brushq3.data_color4f[i * 4 + 1] = Image_LinearFloatFromsRGB(in->color4ub[1]); + loadmodel->brushq3.data_color4f[i * 4 + 2] = Image_LinearFloatFromsRGB(in->color4ub[2]); + } + } + else + { + if(vid_sRGB.integer && vid_sRGB_fallback.integer && !vid.sRGB3D) + { + loadmodel->brushq3.data_color4f[i * 4 + 0] = Image_sRGBFloatFromLinear_Lightmap(in->color4ub[0]); + loadmodel->brushq3.data_color4f[i * 4 + 1] = Image_sRGBFloatFromLinear_Lightmap(in->color4ub[1]); + loadmodel->brushq3.data_color4f[i * 4 + 2] = Image_sRGBFloatFromLinear_Lightmap(in->color4ub[2]); + } + else + { + loadmodel->brushq3.data_color4f[i * 4 + 0] = in->color4ub[0] * (1.0f / 255.0f); + loadmodel->brushq3.data_color4f[i * 4 + 1] = in->color4ub[1] * (1.0f / 255.0f); + loadmodel->brushq3.data_color4f[i * 4 + 2] = in->color4ub[2] * (1.0f / 255.0f); + } + } loadmodel->brushq3.data_color4f[i * 4 + 3] = in->color4ub[3] * (1.0f / 255.0f); + if(in->color4ub[0] != 255 || in->color4ub[1] != 255 || in->color4ub[2] != 255) + loadmodel->lit = true; } } @@ -4556,8 +5528,16 @@ static void Mod_Q3BSP_LoadTriangles(lump_t *l) if (l->filelen % sizeof(int[3])) Host_Error("Mod_Q3BSP_LoadTriangles: funny lump size in %s",loadmodel->name); count = l->filelen / sizeof(*in); - out = (int *)Mem_Alloc(loadmodel->mempool, count * sizeof(*out)); + if(!loadmodel->brushq3.num_vertices) + { + if (count) + Con_Printf("Mod_Q3BSP_LoadTriangles: %s has triangles but no vertexes, broken compiler, ignoring problem\n", loadmodel->name); + loadmodel->brushq3.num_triangles = 0; + return; + } + + out = (int *)Mem_Alloc(loadmodel->mempool, count * sizeof(*out)); loadmodel->brushq3.num_triangles = count / 3; loadmodel->brushq3.data_element3i = out; @@ -4567,8 +5547,6 @@ 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; } } @@ -4577,14 +5555,35 @@ static void Mod_Q3BSP_LoadTriangles(lump_t *l) static void Mod_Q3BSP_LoadLightmaps(lump_t *l, lump_t *faceslump) { q3dlightmap_t *input_pointer; - int i, j, k, count, power, power2, mask, endlightmap, mergewidth, mergeheight; + int i; + int j; + int k; + int count; + int powerx; + int powery; + int powerxy; + int powerdxy; + int endlightmap; + int mergegoal; + int lightmapindex; + int realcount; + int realindex; + int mergedwidth; + int mergedheight; + int mergedcolumns; + int mergedrows; + int mergedrowsxcolumns; + int size; + int bytesperpixel; + int rgbmap[3]; unsigned char *c; - - unsigned char *convertedpixels; + unsigned char *mergedpixels; + unsigned char *mergeddeluxepixels; + unsigned char *mergebuf; char mapname[MAX_QPATH]; - int size, bytesperpixel, rgbmap[3]; qboolean external; unsigned char *inpixels[10000]; // max count q3map2 can output (it uses 4 digits) + char vabuf[1024]; // defaults for q3bsp size = 128; @@ -4621,7 +5620,7 @@ static void Mod_Q3BSP_LoadLightmaps(lump_t *l, lump_t *faceslump) 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); + inpixels[0] = loadimagepixelsbgra(va(vabuf, sizeof(vabuf), "%s/lm_%04d", mapname, 0), false, false, false, NULL); if(!inpixels[0]) return; @@ -4641,19 +5640,19 @@ static void Mod_Q3BSP_LoadLightmaps(lump_t *l, lump_t *faceslump) for(count = 1; ; ++count) { - inpixels[count] = loadimagepixelsbgra(va("%s/lm_%04d", mapname, count), false, false); + inpixels[count] = loadimagepixelsbgra(va(vabuf, sizeof(vabuf), "%s/lm_%04d", mapname, count), false, false, false, NULL); 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); + Mem_Free(inpixels[count]); + inpixels[count] = NULL; + Con_Printf("Mod_Q3BSP_LoadLightmaps: mismatched lightmap size in %s - external lightmap %s/lm_%04d does not match earlier ones\n", loadmodel->name, mapname, count); + break; } } } - convertedpixels = (unsigned char *) Mem_Alloc(tempmempool, size*size*4); loadmodel->brushq3.lightmapsize = size; loadmodel->brushq3.num_originallightmaps = count; @@ -4666,51 +5665,56 @@ 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; + } } } } - } - // 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) - { - c = inpixels[1]; - for (i = 0;i < size*size;i++) + // 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) { - 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; + 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; + } } } @@ -4718,81 +5722,106 @@ static void Mod_Q3BSP_LoadLightmaps(lump_t *l, lump_t *faceslump) // figure out what the most reasonable merge power is within limits - loadmodel->brushq3.num_lightmapmergepower = 0; - - for(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) <= gl_max_texture_size && (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 : 0)) + (1 << (loadmodel->brushq3.num_lightmapmergepower * 2)) - 1) >> (loadmodel->brushq3.num_lightmapmergepower * 2); + // find the appropriate NxN dimensions to merge to, to avoid wasted space + realcount = count >> (int)loadmodel->brushq3.deluxemapping; + + // figure out how big the merged texture has to be + mergegoal = 128< size && mergegoal * mergegoal / 4 >= size * size * realcount) + mergegoal /= 2; + mergedwidth = mergegoal; + mergedheight = mergegoal; + // choose non-square size (2x1 aspect) if only half the space is used; + // this really only happens when the entire set fits in one texture, if + // there are multiple textures, we don't worry about shrinking the last + // one to fit, because the driver prefers the same texture size on + // consecutive draw calls... + if (mergedwidth * mergedheight / 2 >= size*size*realcount) + mergedheight /= 2; + + loadmodel->brushq3.num_lightmapmergedwidthpower = 0; + loadmodel->brushq3.num_lightmapmergedheightpower = 0; + while (mergedwidth > size<brushq3.num_lightmapmergedwidthpower) + loadmodel->brushq3.num_lightmapmergedwidthpower++; + while (mergedheight > size<brushq3.num_lightmapmergedheightpower) + loadmodel->brushq3.num_lightmapmergedheightpower++; + loadmodel->brushq3.num_lightmapmergedwidthheightdeluxepower = loadmodel->brushq3.num_lightmapmergedwidthpower + loadmodel->brushq3.num_lightmapmergedheightpower + (loadmodel->brushq3.deluxemapping ? 1 : 0); + + powerx = loadmodel->brushq3.num_lightmapmergedwidthpower; + powery = loadmodel->brushq3.num_lightmapmergedheightpower; + powerxy = powerx+powery; + powerdxy = loadmodel->brushq3.deluxemapping + powerxy; + + mergedcolumns = 1 << powerx; + mergedrows = 1 << powery; + mergedrowsxcolumns = 1 << powerxy; + + loadmodel->brushq3.num_mergedlightmaps = (realcount + (1 << powerxy) - 1) >> powerxy; 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 *)); // allocate a texture pool if we need it - if (loadmodel->texturepool == NULL && cls.state != ca_dedicated) + if (loadmodel->texturepool == NULL) loadmodel->texturepool = R_AllocTexturePool(); - power = loadmodel->brushq3.num_lightmapmergepower; - power2 = power * 2; - mask = (1 << power) - 1; + mergedpixels = (unsigned char *) Mem_Alloc(tempmempool, mergedwidth * mergedheight * 4); + mergeddeluxepixels = loadmodel->brushq3.deluxemapping ? (unsigned char *) Mem_Alloc(tempmempool, mergedwidth * mergedheight * 4) : NULL; 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) - { - // if the lightmap has not been allocated yet, create it - if (!loadmodel->brushq3.data_lightmaps[lightmapindex]) - { - // create a lightmap only as large as necessary to hold the - // remaining size*size blocks - // if there are multiple merged lightmap textures then they will - // all be full size except the last one which may be smaller - // because it only needs to the remaining blocks, and it will often - // be odd sizes like 2048x512 due to only being 25% full or so. - j = (count >> (loadmodel->brushq3.deluxemapping ? 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) - ; - if (developer_loading.integer) - Con_Printf("lightmap merge texture #%i is %ix%i (%i of %i used)\n", lightmapindex, mergewidth*size, mergeheight*size, min(j, mergewidth*mergeheight), mergewidth*mergeheight); - loadmodel->brushq3.data_lightmaps[lightmapindex] = R_LoadTexture2D(loadmodel->texturepool, va("lightmap%04i", lightmapindex), mergewidth * size, mergeheight * size, NULL, TEXTYPE_BGRA, TEXF_FORCELINEAR | TEXF_PRECACHE | (gl_texturecompression_q3bsplightmaps.integer ? TEXF_COMPRESS : 0), NULL); - if (loadmodel->brushq3.data_deluxemaps) - loadmodel->brushq3.data_deluxemaps[lightmapindex] = R_LoadTexture2D(loadmodel->texturepool, va("deluxemap%04i", lightmapindex), mergewidth * size, mergeheight * size, NULL, TEXTYPE_BGRA, TEXF_FORCELINEAR | TEXF_PRECACHE | (gl_texturecompression_q3bspdeluxemaps.integer ? TEXF_COMPRESS : 0), NULL); - } - mergewidth = R_TextureWidth(loadmodel->brushq3.data_lightmaps[lightmapindex]) / size; - mergeheight = R_TextureHeight(loadmodel->brushq3.data_lightmaps[lightmapindex]) / size; - j = (i >> (loadmodel->brushq3.deluxemapping ? 1 : 0)) & ((1 << power2) - 1); - if (loadmodel->brushq3.deluxemapping && (i & 1)) - R_UpdateTexture(loadmodel->brushq3.data_deluxemaps[lightmapindex], convertedpixels, (j % mergewidth) * size, (j / mergewidth) * size, size, size); - else - R_UpdateTexture(loadmodel->brushq3.data_lightmaps [lightmapindex], convertedpixels, (j % mergewidth) * size, (j / mergewidth) * size, size, size); + realindex = i >> (int)loadmodel->brushq3.deluxemapping; + lightmapindex = i >> powerdxy; + + // choose the destination address + mergebuf = (loadmodel->brushq3.deluxemapping && (i & 1)) ? mergeddeluxepixels : mergedpixels; + mergebuf += 4 * (realindex & (mergedcolumns-1))*size + 4 * ((realindex >> powerx) & (mergedrows-1))*mergedwidth*size; + if ((i & 1) == 0 || !loadmodel->brushq3.deluxemapping) + Con_DPrintf("copying original lightmap %i (%ix%i) to %i (at %i,%i)\n", i, size, size, lightmapindex, (realindex & (mergedcolumns-1))*size, ((realindex >> powerx) & (mergedrows-1))*size); + + // convert pixels from RGB or BGRA while copying them into the destination rectangle + for (j = 0;j < size;j++) + for (k = 0;k < size;k++) + { + mergebuf[(j*mergedwidth+k)*4+0] = inpixels[i][(j*size+k)*bytesperpixel+rgbmap[0]]; + mergebuf[(j*mergedwidth+k)*4+1] = inpixels[i][(j*size+k)*bytesperpixel+rgbmap[1]]; + mergebuf[(j*mergedwidth+k)*4+2] = inpixels[i][(j*size+k)*bytesperpixel+rgbmap[2]]; + mergebuf[(j*mergedwidth+k)*4+3] = 255; } - else + + // upload texture if this was the last tile being written to the texture + if (((realindex + 1) & (mergedrowsxcolumns - 1)) == 0 || (realindex + 1) == realcount) { - // figure out which merged lightmap texture this fits into if (loadmodel->brushq3.deluxemapping && (i & 1)) - loadmodel->brushq3.data_deluxemaps[lightmapindex] = R_LoadTexture2D(loadmodel->texturepool, va("deluxemap%04i", lightmapindex), size, size, convertedpixels, TEXTYPE_BGRA, TEXF_FORCELINEAR | TEXF_PRECACHE | (gl_texturecompression_q3bspdeluxemaps.integer ? TEXF_COMPRESS : 0), NULL); + loadmodel->brushq3.data_deluxemaps[lightmapindex] = R_LoadTexture2D(loadmodel->texturepool, va(vabuf, sizeof(vabuf), "deluxemap%04i", lightmapindex), mergedwidth, mergedheight, mergeddeluxepixels, TEXTYPE_BGRA, TEXF_FORCELINEAR | (gl_texturecompression_q3bspdeluxemaps.integer ? TEXF_COMPRESS : 0), -1, NULL); else - loadmodel->brushq3.data_lightmaps [lightmapindex] = R_LoadTexture2D(loadmodel->texturepool, va("lightmap%04i", lightmapindex), size, size, convertedpixels, TEXTYPE_BGRA, TEXF_FORCELINEAR | TEXF_PRECACHE | (gl_texturecompression_q3bsplightmaps.integer ? TEXF_COMPRESS : 0), NULL); + { + if(mod_q3bsp_sRGBlightmaps.integer) + { + textype_t t; + if(vid_sRGB.integer && vid_sRGB_fallback.integer && !vid.sRGB3D) + { + t = TEXTYPE_BGRA; // in stupid fallback mode, we upload lightmaps in sRGB form and just fix their brightness + // we fix the brightness consistently via lightmapscale + } + else + t = TEXTYPE_SRGB_BGRA; // normally, we upload lightmaps in sRGB form (possibly downconverted to linear) + loadmodel->brushq3.data_lightmaps [lightmapindex] = R_LoadTexture2D(loadmodel->texturepool, va(vabuf, sizeof(vabuf), "lightmap%04i", lightmapindex), mergedwidth, mergedheight, mergedpixels, t, TEXF_FORCELINEAR | (gl_texturecompression_q3bsplightmaps.integer ? TEXF_COMPRESS : 0), -1, NULL); + } + else + { + if(vid_sRGB.integer && vid_sRGB_fallback.integer && !vid.sRGB3D) + Image_MakesRGBColorsFromLinear_Lightmap(mergedpixels, mergedpixels, mergedwidth * mergedheight); + loadmodel->brushq3.data_lightmaps [lightmapindex] = R_LoadTexture2D(loadmodel->texturepool, va(vabuf, sizeof(vabuf), "lightmap%04i", lightmapindex), mergedwidth, mergedheight, mergedpixels, TEXTYPE_BGRA, TEXF_FORCELINEAR | (gl_texturecompression_q3bsplightmaps.integer ? TEXF_COMPRESS : 0), -1, NULL); + } + } } } - Mem_Free(convertedpixels); + if (mergeddeluxepixels) + Mem_Free(mergeddeluxepixels); + Mem_Free(mergedpixels); if(external) { for(i = 0; i < count; ++i) @@ -4805,9 +5834,9 @@ static void Mod_Q3BSP_BuildBBoxes(const int *element3i, int num_triangles, const int j, k, cnt, tri; float *mins, *maxs; const float *vert; + *collisionstride = stride; if(stride > 0) { - *collisionstride = stride; cnt = (num_triangles + stride - 1) / stride; *collisionbbox6f = (float *) Mem_Alloc(loadmodel->mempool, sizeof(float[6]) * cnt); for(j = 0; j < cnt; ++j) @@ -4844,10 +5873,7 @@ static void Mod_Q3BSP_BuildBBoxes(const int *element3i, int num_triangles, const } } else - { - *collisionstride = 0; *collisionbbox6f = NULL; - } } typedef struct patchtess_s @@ -4874,10 +5900,9 @@ 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, cxtess, cytess; + int i, oldi, j, n, count, invalidelements, patchsize[2], finalwidth, finalheight, xtess, ytess, finalvertices, finaltriangles, firstvertex, firstelement, type, oldnumtriangles, oldnumtriangles2, meshvertices, meshtriangles, collisionvertices, collisiontriangles, numvertices, numtriangles, cxtess, cytess; float lightmaptcbase[2], lightmaptcscale[2]; //int *originalelement3i; - //int *originalneighbor3i; float *originalvertex3f; //float *originalsvector3f; //float *originaltvector3f; @@ -4885,6 +5910,8 @@ static void Mod_Q3BSP_LoadFaces(lump_t *l) float *originalcolor4f; float *originaltexcoordtexture2f; float *originaltexcoordlightmap2f; + float *surfacecollisionvertex3f; + int *surfacecollisionelement3i; float *v; patchtess_t *patchtess = NULL; int patchtesscount = 0; @@ -4931,8 +5958,8 @@ static void Mod_Q3BSP_LoadFaces(lump_t *l) n = LittleLong(in->effectindex); if (n < -1 || n >= loadmodel->brushq3.num_effects) { - if (developer.integer >= 100) - Con_Printf("Mod_Q3BSP_LoadFaces: face #%i (texture \"%s\"): invalid effectindex %i (%i effects)\n", i, out->texture->name, n, loadmodel->brushq3.num_effects); + if (developer_extra.integer) + Con_DPrintf("Mod_Q3BSP_LoadFaces: face #%i (texture \"%s\"): invalid effectindex %i (%i effects)\n", i, out->texture->name, n, loadmodel->brushq3.num_effects); n = -1; } if (n == -1) @@ -4955,9 +5982,10 @@ static void Mod_Q3BSP_LoadFaces(lump_t *l) } else { - out->lightmaptexture = loadmodel->brushq3.data_lightmaps[n >> (loadmodel->brushq3.num_lightmapmergepower * 2 + loadmodel->brushq3.deluxemapping)]; + out->lightmaptexture = loadmodel->brushq3.data_lightmaps[n >> loadmodel->brushq3.num_lightmapmergedwidthheightdeluxepower]; if (loadmodel->brushq3.deluxemapping) - out->deluxemaptexture = loadmodel->brushq3.data_deluxemaps[n >> (loadmodel->brushq3.num_lightmapmergepower * 2 + loadmodel->brushq3.deluxemapping)]; + out->deluxemaptexture = loadmodel->brushq3.data_deluxemaps[n >> loadmodel->brushq3.num_lightmapmergedwidthheightdeluxepower]; + loadmodel->lit = true; } } @@ -5026,18 +6054,18 @@ static void Mod_Q3BSP_LoadFaces(lump_t *l) 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].lodgroup[0] = LittleFloat(in->specific.patch.mins[0]); + patchtess[patchtesscount].lodgroup[1] = LittleFloat(in->specific.patch.mins[1]); + patchtess[patchtesscount].lodgroup[2] = LittleFloat(in->specific.patch.mins[2]); + patchtess[patchtesscount].lodgroup[3] = LittleFloat(in->specific.patch.maxs[0]); + patchtess[patchtesscount].lodgroup[4] = LittleFloat(in->specific.patch.maxs[1]); + patchtess[patchtesscount].lodgroup[5] = LittleFloat(in->specific.patch.maxs[2]); patchtess[patchtesscount].originalvertex3f = originalvertex3f; ++patchtesscount; break; case Q3FACETYPE_FLARE: - if (developer.integer >= 100) - Con_Printf("Mod_Q3BSP_LoadFaces: face #%i (texture \"%s\"): Q3FACETYPE_FLARE not supported (yet)\n", i, out->texture->name); + if (developer_extra.integer) + Con_DPrintf("Mod_Q3BSP_LoadFaces: face #%i (texture \"%s\"): Q3FACETYPE_FLARE not supported (yet)\n", i, out->texture->name); // don't render it continue; } @@ -5066,6 +6094,8 @@ static void Mod_Q3BSP_LoadFaces(lump_t *l) while (again); // Calculate resulting number of triangles + collisionvertices = 0; + collisiontriangles = 0; for(i = 0; i < patchtesscount; ++i) { finalwidth = Q3PatchDimForTess(patchtess[i].info.xsize, patchtess[i].info.lods[PATCH_LOD_VISUAL].xtess); @@ -5077,14 +6107,31 @@ static void Mod_Q3BSP_LoadFaces(lump_t *l) oldout[patchtess[i].surface_id].num_triangles = numtriangles; meshvertices += oldout[patchtess[i].surface_id].num_vertices; meshtriangles += oldout[patchtess[i].surface_id].num_triangles; + + finalwidth = Q3PatchDimForTess(patchtess[i].info.xsize, patchtess[i].info.lods[PATCH_LOD_COLLISION].xtess); + finalheight = Q3PatchDimForTess(patchtess[i].info.ysize,patchtess[i].info.lods[PATCH_LOD_COLLISION].ytess); + numvertices = finalwidth * finalheight; + numtriangles = (finalwidth - 1) * (finalheight - 1) * 2; + + oldout[patchtess[i].surface_id].num_collisionvertices = numvertices; + oldout[patchtess[i].surface_id].num_collisiontriangles = numtriangles; + collisionvertices += oldout[patchtess[i].surface_id].num_collisionvertices; + collisiontriangles += oldout[patchtess[i].surface_id].num_collisiontriangles; } i = oldi; in = oldin; out = oldout; - Mod_AllocSurfMesh(loadmodel->mempool, meshvertices, meshtriangles, false, true, false); + Mod_AllocSurfMesh(loadmodel->mempool, meshvertices, meshtriangles, false, true); + if (collisiontriangles) + { + loadmodel->brush.data_collisionvertex3f = (float *)Mem_Alloc(loadmodel->mempool, collisionvertices * sizeof(float[3])); + loadmodel->brush.data_collisionelement3i = (int *)Mem_Alloc(loadmodel->mempool, collisiontriangles * sizeof(int[3])); + } meshvertices = 0; meshtriangles = 0; + collisionvertices = 0; + collisiontriangles = 0; for (;i < count && meshvertices + out->num_vertices <= loadmodel->surfmesh.num_vertices;i++, in++, out++) { if (out->num_vertices < 3 || out->num_triangles < 1) @@ -5095,6 +6142,7 @@ static void Mod_Q3BSP_LoadFaces(lump_t *l) firstelement = LittleLong(in->firstelement); out->num_firstvertex = meshvertices; out->num_firsttriangle = meshtriangles; + out->num_firstcollisiontriangle = collisiontriangles; switch(type) { case Q3FACETYPE_FLAT: @@ -5148,7 +6196,7 @@ static void Mod_Q3BSP_LoadFaces(lump_t *l) 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; + oldnumtriangles = finaltriangles = (finalwidth - 1) * (finalheight - 1) * 2; type = Q3FACETYPE_MESH; // generate geometry // (note: normals are skipped because they get recalculated) @@ -5161,40 +6209,62 @@ static void Mod_Q3BSP_LoadFaces(lump_t *l) 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 (developer_extra.integer) { if (out->num_triangles < finaltriangles) - Con_Printf("Mod_Q3BSP_LoadFaces: %ix%i curve subdivided to %i vertices / %i triangles, %i degenerate triangles removed (leaving %i)\n", patchsize[0], patchsize[1], out->num_vertices, finaltriangles, finaltriangles - out->num_triangles, out->num_triangles); + Con_DPrintf("Mod_Q3BSP_LoadFaces: %ix%i curve subdivided to %i vertices / %i triangles, %i degenerate triangles removed (leaving %i)\n", patchsize[0], patchsize[1], out->num_vertices, finaltriangles, finaltriangles - out->num_triangles, out->num_triangles); else - Con_Printf("Mod_Q3BSP_LoadFaces: %ix%i curve subdivided to %i vertices / %i triangles\n", patchsize[0], patchsize[1], out->num_vertices, out->num_triangles); + Con_DPrintf("Mod_Q3BSP_LoadFaces: %ix%i curve subdivided to %i vertices / %i triangles\n", patchsize[0], patchsize[1], out->num_vertices, out->num_triangles); } // q3map does not put in collision brushes for curves... ugh // build the lower quality collision geometry 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; + oldnumtriangles2 = finaltriangles = (finalwidth - 1) * (finalheight - 1) * 2; - out->data_collisionvertex3f = (float *)Mem_Alloc(loadmodel->mempool, sizeof(float[3]) * finalvertices); - out->data_collisionelement3i = (int *)Mem_Alloc(loadmodel->mempool, sizeof(int[3]) * finaltriangles); + // legacy collision geometry implementation + out->deprecatedq3data_collisionvertex3f = (float *)Mem_Alloc(loadmodel->mempool, sizeof(float[3]) * finalvertices); + out->deprecatedq3data_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, cxtess, cytess); - Q3PatchTriangleElements(out->data_collisionelement3i, finalwidth, finalheight, 0); + Q3PatchTesselateFloat(3, sizeof(float[3]), out->deprecatedq3data_collisionvertex3f, patchsize[0], patchsize[1], sizeof(float[3]), originalvertex3f, cxtess, cytess); + Q3PatchTriangleElements(out->deprecatedq3data_collisionelement3i, finalwidth, finalheight, 0); //Mod_SnapVertices(3, out->num_vertices, (loadmodel->surfmesh.data_vertex3f + 3 * out->num_firstvertex), 0.25); - Mod_SnapVertices(3, out->num_collisionvertices, out->data_collisionvertex3f, 1); + Mod_SnapVertices(3, finalvertices, out->deprecatedq3data_collisionvertex3f, 1); - 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); + out->num_collisiontriangles = Mod_RemoveDegenerateTriangles(finaltriangles, out->deprecatedq3data_collisionelement3i, out->deprecatedq3data_collisionelement3i, out->deprecatedq3data_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); + Mod_Q3BSP_BuildBBoxes(out->deprecatedq3data_collisionelement3i, out->num_collisiontriangles, out->deprecatedq3data_collisionvertex3f, &out->deprecatedq3data_collisionbbox6f, &out->deprecatedq3num_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->deprecatedq3data_bbox6f, &out->deprecatedq3num_bboxstride, mod_q3bsp_curves_stride.integer); + + // store collision geometry for BIH collision tree + surfacecollisionvertex3f = loadmodel->brush.data_collisionvertex3f + collisionvertices * 3; + surfacecollisionelement3i = loadmodel->brush.data_collisionelement3i + collisiontriangles * 3; + Q3PatchTesselateFloat(3, sizeof(float[3]), surfacecollisionvertex3f, patchsize[0], patchsize[1], sizeof(float[3]), originalvertex3f, cxtess, cytess); + Q3PatchTriangleElements(surfacecollisionelement3i, finalwidth, finalheight, collisionvertices); + Mod_SnapVertices(3, finalvertices, surfacecollisionvertex3f, 1); +#if 1 + // remove this once the legacy code is removed + { + int nc = out->num_collisiontriangles; +#endif + out->num_collisiontriangles = Mod_RemoveDegenerateTriangles(finaltriangles, surfacecollisionelement3i, surfacecollisionelement3i, loadmodel->brush.data_collisionvertex3f); +#if 1 + if(nc != out->num_collisiontriangles) + { + Con_Printf("number of collision triangles differs between BIH and BSP. FAIL.\n"); + } + } +#endif + + if (developer_extra.integer) + Con_DPrintf("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); - 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); + collisionvertices += finalvertices; + collisiontriangles += out->num_collisiontriangles; break; default: break; @@ -5270,13 +6340,20 @@ static void Mod_Q3BSP_LoadFaces(lump_t *l) 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); + { + Con_Printf("Mod_Q3BSP_LoadFaces: surface %d (texture %s) has no vertices, ignoring\n", i, out->texture ? out->texture->name : "(none)"); + if(out->num_triangles == 0) + Con_Printf("Mod_Q3BSP_LoadFaces: surface %d (texture %s) has no triangles, ignoring\n", i, out->texture ? out->texture->name : "(none)"); + } + else if(out->num_triangles == 0) + Con_Printf("Mod_Q3BSP_LoadFaces: surface %d (texture %s, near %f %f %f) has no triangles, ignoring\n", i, out->texture ? out->texture->name : "(none)", + (loadmodel->surfmesh.data_vertex3f + 3 * out->num_firstvertex)[0 * 3 + 0], + (loadmodel->surfmesh.data_vertex3f + 3 * out->num_firstvertex)[1 * 3 + 0], + (loadmodel->surfmesh.data_vertex3f + 3 * out->num_firstvertex)[2 * 3 + 0]); } // 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); + 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, r_smoothnormals_areaweighting.integer != 0); // generate ushort elements array if possible if (loadmodel->surfmesh.data_element3s) @@ -5439,6 +6516,8 @@ static void Mod_Q3BSP_LoadNodes(lump_t *l) if (l->filelen % sizeof(*in)) Host_Error("Mod_Q3BSP_LoadNodes: funny lump size in %s",loadmodel->name); count = l->filelen / sizeof(*in); + if (count == 0) + Host_Error("Mod_Q3BSP_LoadNodes: missing BSP tree in %s",loadmodel->name); out = (mnode_t *)Mem_Alloc(loadmodel->mempool, count * sizeof(*out)); loadmodel->brush.data_nodes = out; @@ -5485,6 +6564,7 @@ static void Mod_Q3BSP_LoadLightGrid(lump_t *l) q3dlightgrid_t *in; q3dlightgrid_t *out; int count; + int i; in = (q3dlightgrid_t *)(mod_base + l->fileofs); if (l->filelen % sizeof(*in)) @@ -5509,7 +6589,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_isize[0], loadmodel->brushq3.num_lightgrid_isize[1], loadmodel->brushq3.num_lightgrid_isize[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)); @@ -5517,6 +6600,45 @@ static void Mod_Q3BSP_LoadLightGrid(lump_t *l) loadmodel->brushq3.num_lightgrid = count; // no swapping or validation necessary memcpy(out, in, count * (int)sizeof(*out)); + + if(mod_q3bsp_sRGBlightmaps.integer) + { + if(vid_sRGB.integer && vid_sRGB_fallback.integer && !vid.sRGB3D) + { + // we fix the brightness consistently via lightmapscale + } + else + { + for(i = 0; i < count; ++i) + { + out[i].ambientrgb[0] = floor(Image_LinearFloatFromsRGB(out[i].ambientrgb[0]) * 255.0f + 0.5f); + out[i].ambientrgb[1] = floor(Image_LinearFloatFromsRGB(out[i].ambientrgb[1]) * 255.0f + 0.5f); + out[i].ambientrgb[2] = floor(Image_LinearFloatFromsRGB(out[i].ambientrgb[2]) * 255.0f + 0.5f); + out[i].diffusergb[0] = floor(Image_LinearFloatFromsRGB(out[i].diffusergb[0]) * 255.0f + 0.5f); + out[i].diffusergb[1] = floor(Image_LinearFloatFromsRGB(out[i].diffusergb[1]) * 255.0f + 0.5f); + out[i].diffusergb[2] = floor(Image_LinearFloatFromsRGB(out[i].diffusergb[2]) * 255.0f + 0.5f); + } + } + } + else + { + if(vid_sRGB.integer && vid_sRGB_fallback.integer && !vid.sRGB3D) + { + for(i = 0; i < count; ++i) + { + out[i].ambientrgb[0] = floor(Image_sRGBFloatFromLinear_Lightmap(out[i].ambientrgb[0]) * 255.0f + 0.5f); + out[i].ambientrgb[1] = floor(Image_sRGBFloatFromLinear_Lightmap(out[i].ambientrgb[1]) * 255.0f + 0.5f); + out[i].ambientrgb[2] = floor(Image_sRGBFloatFromLinear_Lightmap(out[i].ambientrgb[2]) * 255.0f + 0.5f); + out[i].diffusergb[0] = floor(Image_sRGBFloatFromLinear_Lightmap(out[i].diffusergb[0]) * 255.0f + 0.5f); + out[i].diffusergb[1] = floor(Image_sRGBFloatFromLinear_Lightmap(out[i].diffusergb[1]) * 255.0f + 0.5f); + out[i].diffusergb[2] = floor(Image_sRGBFloatFromLinear_Lightmap(out[i].diffusergb[2]) * 255.0f + 0.5f); + } + } + else + { + // all is good + } + } } } @@ -5561,11 +6683,13 @@ static void Mod_Q3BSP_LoadPVS(lump_t *l) 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; + float transformed[3], blend1, blend2, blend, stylescale = 1; q3dlightgrid_t *a, *s; // scale lighting by lightstyle[0] so that darkmode in dpmod works properly - stylescale = r_refdef.scene.rtlightstylevalue[0]; + // LadyHavoc: FIXME: is this true? + stylescale = 1; // added while render + //stylescale = r_refdef.scene.rtlightstylevalue[0]; if (!model->brushq3.num_lightgrid) { @@ -5623,6 +6747,509 @@ static void Mod_Q3BSP_LightPoint(dp_model_t *model, const vec3_t p, vec3_t ambie //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 int Mod_Q3BSP_TraceLineOfSight_RecursiveNodeCheck(mnode_t *node, double p1[3], double p2[3], double endpos[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, endpos); + if (ret != 0) + return ret; + ret = Mod_Q3BSP_TraceLineOfSight_RecursiveNodeCheck(node->children[side ^ 1], mid, p2, endpos); + if (ret != 1) + return ret; + VectorCopy(mid, endpos); + 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, const vec3_t acceptmins, const vec3_t acceptmaxs) +{ + if (model->brush.submodel || mod_q3bsp_tracelineofsight_brushes.integer) + { + trace_t trace; + model->TraceLine(model, NULL, NULL, &trace, start, end, SUPERCONTENTS_VISBLOCKERMASK, 0, MATERIALFLAGMASK_TRANSLUCENT); + return trace.fraction == 1 || BoxesOverlap(trace.endpos, trace.endpos, acceptmins, acceptmaxs); + } + else + { + double tracestart[3], traceend[3], traceendpos[3]; + VectorCopy(start, tracestart); + VectorCopy(end, traceend); + VectorCopy(end, traceendpos); + Mod_Q3BSP_TraceLineOfSight_RecursiveNodeCheck(model->brush.data_nodes, tracestart, traceend, traceendpos); + return BoxesOverlap(traceendpos, traceendpos, acceptmins, acceptmaxs); + } +} + +void Mod_CollisionBIH_TracePoint(dp_model_t *model, const frameblend_t *frameblend, const skeleton_t *skeleton, trace_t *trace, const vec3_t start, int hitsupercontentsmask, int skipsupercontentsmask, int skipmaterialflagsmask) +{ + const bih_t *bih; + const bih_leaf_t *leaf; + const bih_node_t *node; + const colbrushf_t *brush; + int axis; + int nodenum; + int nodestackpos = 0; + int nodestack[1024]; + + memset(trace, 0, sizeof(*trace)); + trace->fraction = 1; + trace->hitsupercontentsmask = hitsupercontentsmask; + trace->skipsupercontentsmask = skipsupercontentsmask; + trace->skipmaterialflagsmask = skipmaterialflagsmask; + + bih = &model->collision_bih; + if(!bih->nodes) + return; + + nodenum = bih->rootnode; + nodestack[nodestackpos++] = nodenum; + while (nodestackpos) + { + nodenum = nodestack[--nodestackpos]; + node = bih->nodes + nodenum; +#if 1 + if (!BoxesOverlap(start, start, node->mins, node->maxs)) + continue; +#endif + if (node->type <= BIH_SPLITZ && nodestackpos+2 <= 1024) + { + axis = node->type - BIH_SPLITX; + if (start[axis] >= node->frontmin) + nodestack[nodestackpos++] = node->front; + if (start[axis] <= node->backmax) + nodestack[nodestackpos++] = node->back; + } + else if (node->type == BIH_UNORDERED) + { + for (axis = 0;axis < BIH_MAXUNORDEREDCHILDREN && node->children[axis] >= 0;axis++) + { + leaf = bih->leafs + node->children[axis]; +#if 1 + if (!BoxesOverlap(start, start, leaf->mins, leaf->maxs)) + continue; +#endif + switch(leaf->type) + { + case BIH_BRUSH: + brush = model->brush.data_brushes[leaf->itemindex].colbrushf; + Collision_TracePointBrushFloat(trace, start, brush); + break; + case BIH_COLLISIONTRIANGLE: + // collision triangle - skipped because they have no volume + break; + case BIH_RENDERTRIANGLE: + // render triangle - skipped because they have no volume + break; + } + } + } + } +} + +static void Mod_CollisionBIH_TraceLineShared(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 skipsupercontentsmask, int skipmaterialflagsmask, const bih_t *bih) +{ + const bih_leaf_t *leaf; + const bih_node_t *node; + const colbrushf_t *brush; + const int *e; + const texture_t *texture; + vec3_t nodebigmins, nodebigmaxs, nodestart, nodeend, sweepnodemins, sweepnodemaxs; + vec_t d1, d2, d3, d4, f, nodestackline[1024][6]; + int axis, nodenum, nodestackpos = 0, nodestack[1024]; + + if(!bih->nodes) + return; + + if (VectorCompare(start, end)) + { + Mod_CollisionBIH_TracePoint(model, frameblend, skeleton, trace, start, hitsupercontentsmask, skipsupercontentsmask, skipmaterialflagsmask); + return; + } + + nodenum = bih->rootnode; + + memset(trace, 0, sizeof(*trace)); + trace->fraction = 1; + trace->hitsupercontentsmask = hitsupercontentsmask; + trace->skipsupercontentsmask = skipsupercontentsmask; + trace->skipmaterialflagsmask = skipmaterialflagsmask; + + // push first node + nodestackline[nodestackpos][0] = start[0]; + nodestackline[nodestackpos][1] = start[1]; + nodestackline[nodestackpos][2] = start[2]; + nodestackline[nodestackpos][3] = end[0]; + nodestackline[nodestackpos][4] = end[1]; + nodestackline[nodestackpos][5] = end[2]; + nodestack[nodestackpos++] = nodenum; + while (nodestackpos) + { + nodenum = nodestack[--nodestackpos]; + node = bih->nodes + nodenum; + VectorCopy(nodestackline[nodestackpos], nodestart); + VectorCopy(nodestackline[nodestackpos] + 3, nodeend); + sweepnodemins[0] = min(nodestart[0], nodeend[0]) - 1; + sweepnodemins[1] = min(nodestart[1], nodeend[1]) - 1; + sweepnodemins[2] = min(nodestart[2], nodeend[2]) - 1; + sweepnodemaxs[0] = max(nodestart[0], nodeend[0]) + 1; + sweepnodemaxs[1] = max(nodestart[1], nodeend[1]) + 1; + sweepnodemaxs[2] = max(nodestart[2], nodeend[2]) + 1; + if (!BoxesOverlap(sweepnodemins, sweepnodemaxs, node->mins, node->maxs) && !collision_bih_fullrecursion.integer) + continue; + if (node->type <= BIH_SPLITZ && nodestackpos+2 <= 1024) + { + // recurse children of the split + axis = node->type - BIH_SPLITX; + d1 = node->backmax - nodestart[axis]; + d2 = node->backmax - nodeend[axis]; + d3 = nodestart[axis] - node->frontmin; + d4 = nodeend[axis] - node->frontmin; + if (collision_bih_fullrecursion.integer) + d1 = d2 = d3 = d4 = 1; // force full recursion + switch((d1 < 0) | ((d2 < 0) << 1) | ((d3 < 0) << 2) | ((d4 < 0) << 3)) + { + case 0: /* >>>> */ VectorCopy(nodestart, nodestackline[nodestackpos]); VectorCopy( nodeend, nodestackline[nodestackpos] + 3); nodestack[nodestackpos++] = node->back; VectorCopy(nodestart, nodestackline[nodestackpos]); VectorCopy( nodeend, nodestackline[nodestackpos] + 3); nodestack[nodestackpos++] = node->front; break; + case 1: /* <>>> */ f = d1 / (d1 - d2); VectorLerp(nodestart, f, nodeend, nodestackline[nodestackpos]); VectorCopy( nodeend, nodestackline[nodestackpos] + 3); nodestack[nodestackpos++] = node->back; VectorCopy(nodestart, nodestackline[nodestackpos]); VectorCopy( nodeend, nodestackline[nodestackpos] + 3); nodestack[nodestackpos++] = node->front; break; + case 2: /* ><>> */ f = d1 / (d1 - d2); VectorCopy(nodestart, nodestackline[nodestackpos]); VectorLerp(nodestart, f, nodeend, nodestackline[nodestackpos] + 3); nodestack[nodestackpos++] = node->back; VectorCopy(nodestart, nodestackline[nodestackpos]); VectorCopy( nodeend, nodestackline[nodestackpos] + 3); nodestack[nodestackpos++] = node->front; break; + case 3: /* <<>> */ VectorCopy(nodestart, nodestackline[nodestackpos]); VectorCopy( nodeend, nodestackline[nodestackpos] + 3); nodestack[nodestackpos++] = node->front; break; + case 4: /* >><> */ VectorCopy(nodestart, nodestackline[nodestackpos]); VectorCopy( nodeend, nodestackline[nodestackpos] + 3); nodestack[nodestackpos++] = node->back; f = d3 / (d3 - d4); VectorLerp(nodestart, f, nodeend, nodestackline[nodestackpos]); VectorCopy( nodeend, nodestackline[nodestackpos] + 3); nodestack[nodestackpos++] = node->front; break; + case 5: /* <><> */ f = d1 / (d1 - d2); VectorLerp(nodestart, f, nodeend, nodestackline[nodestackpos]); VectorCopy( nodeend, nodestackline[nodestackpos] + 3); nodestack[nodestackpos++] = node->back; f = d3 / (d3 - d4); VectorLerp(nodestart, f, nodeend, nodestackline[nodestackpos]); VectorCopy( nodeend, nodestackline[nodestackpos] + 3); nodestack[nodestackpos++] = node->front; break; + case 6: /* ><<> */ f = d1 / (d1 - d2); VectorCopy(nodestart, nodestackline[nodestackpos]); VectorLerp(nodestart, f, nodeend, nodestackline[nodestackpos] + 3); nodestack[nodestackpos++] = node->back; f = d3 / (d3 - d4); VectorLerp(nodestart, f, nodeend, nodestackline[nodestackpos]); VectorCopy( nodeend, nodestackline[nodestackpos] + 3); nodestack[nodestackpos++] = node->front; break; + case 7: /* <<<> */ f = d3 / (d3 - d4); VectorLerp(nodestart, f, nodeend, nodestackline[nodestackpos]); VectorCopy( nodeend, nodestackline[nodestackpos] + 3); nodestack[nodestackpos++] = node->front; break; + case 8: /* >>>< */ VectorCopy(nodestart, nodestackline[nodestackpos]); VectorCopy( nodeend, nodestackline[nodestackpos] + 3); nodestack[nodestackpos++] = node->back; f = d3 / (d3 - d4); VectorCopy(nodestart, nodestackline[nodestackpos]); VectorLerp(nodestart, f, nodeend, nodestackline[nodestackpos] + 3); nodestack[nodestackpos++] = node->front; break; + case 9: /* <>>< */ f = d1 / (d1 - d2); VectorLerp(nodestart, f, nodeend, nodestackline[nodestackpos]); VectorCopy( nodeend, nodestackline[nodestackpos] + 3); nodestack[nodestackpos++] = node->back; f = d3 / (d3 - d4); VectorCopy(nodestart, nodestackline[nodestackpos]); VectorLerp(nodestart, f, nodeend, nodestackline[nodestackpos] + 3); nodestack[nodestackpos++] = node->front; break; + case 10: /* ><>< */ f = d1 / (d1 - d2); VectorCopy(nodestart, nodestackline[nodestackpos]); VectorLerp(nodestart, f, nodeend, nodestackline[nodestackpos] + 3); nodestack[nodestackpos++] = node->back; f = d3 / (d3 - d4); VectorCopy(nodestart, nodestackline[nodestackpos]); VectorLerp(nodestart, f, nodeend, nodestackline[nodestackpos] + 3); nodestack[nodestackpos++] = node->front; break; + case 11: /* <<>< */ f = d3 / (d3 - d4); VectorCopy(nodestart, nodestackline[nodestackpos]); VectorLerp(nodestart, f, nodeend, nodestackline[nodestackpos] + 3); nodestack[nodestackpos++] = node->front; break; + case 12: /* >><< */ VectorCopy(nodestart, nodestackline[nodestackpos]); VectorCopy( nodeend, nodestackline[nodestackpos] + 3); nodestack[nodestackpos++] = node->back; break; + case 13: /* <><< */ f = d1 / (d1 - d2); VectorLerp(nodestart, f, nodeend, nodestackline[nodestackpos]); VectorCopy( nodeend, nodestackline[nodestackpos] + 3); nodestack[nodestackpos++] = node->back; break; + case 14: /* ><<< */ f = d1 / (d1 - d2); VectorCopy(nodestart, nodestackline[nodestackpos]); VectorLerp(nodestart, f, nodeend, nodestackline[nodestackpos] + 3); nodestack[nodestackpos++] = node->back; break; + case 15: /* <<<< */ break; + } + } + else if (node->type == BIH_UNORDERED) + { + // calculate sweep bounds for this node + // copy node bounds into local variables + VectorCopy(node->mins, nodebigmins); + VectorCopy(node->maxs, nodebigmaxs); + // clip line to this node bounds + axis = 0; d1 = nodestart[axis] - nodebigmins[axis]; d2 = nodeend[axis] - nodebigmins[axis]; if (d1 < 0) { if (d2 < 0) continue; f = d1 / (d1 - d2); VectorLerp(nodestart, f, nodeend, nodestart); } else if (d2 < 0) { f = d1 / (d1 - d2); VectorLerp(nodestart, f, nodeend, nodeend); } d1 = nodebigmaxs[axis] - nodestart[axis]; d2 = nodebigmaxs[axis] - nodeend[axis]; if (d1 < 0) { if (d2 < 0) continue; f = d1 / (d1 - d2); VectorLerp(nodestart, f, nodeend, nodestart); } else if (d2 < 0) { f = d1 / (d1 - d2); VectorLerp(nodestart, f, nodeend, nodeend); } + axis = 1; d1 = nodestart[axis] - nodebigmins[axis]; d2 = nodeend[axis] - nodebigmins[axis]; if (d1 < 0) { if (d2 < 0) continue; f = d1 / (d1 - d2); VectorLerp(nodestart, f, nodeend, nodestart); } else if (d2 < 0) { f = d1 / (d1 - d2); VectorLerp(nodestart, f, nodeend, nodeend); } d1 = nodebigmaxs[axis] - nodestart[axis]; d2 = nodebigmaxs[axis] - nodeend[axis]; if (d1 < 0) { if (d2 < 0) continue; f = d1 / (d1 - d2); VectorLerp(nodestart, f, nodeend, nodestart); } else if (d2 < 0) { f = d1 / (d1 - d2); VectorLerp(nodestart, f, nodeend, nodeend); } + axis = 2; d1 = nodestart[axis] - nodebigmins[axis]; d2 = nodeend[axis] - nodebigmins[axis]; if (d1 < 0) { if (d2 < 0) continue; f = d1 / (d1 - d2); VectorLerp(nodestart, f, nodeend, nodestart); } else if (d2 < 0) { f = d1 / (d1 - d2); VectorLerp(nodestart, f, nodeend, nodeend); } d1 = nodebigmaxs[axis] - nodestart[axis]; d2 = nodebigmaxs[axis] - nodeend[axis]; if (d1 < 0) { if (d2 < 0) continue; f = d1 / (d1 - d2); VectorLerp(nodestart, f, nodeend, nodestart); } else if (d2 < 0) { f = d1 / (d1 - d2); VectorLerp(nodestart, f, nodeend, nodeend); } + // some of the line intersected the enlarged node box + // calculate sweep bounds for this node + sweepnodemins[0] = min(nodestart[0], nodeend[0]) - 1; + sweepnodemins[1] = min(nodestart[1], nodeend[1]) - 1; + sweepnodemins[2] = min(nodestart[2], nodeend[2]) - 1; + sweepnodemaxs[0] = max(nodestart[0], nodeend[0]) + 1; + sweepnodemaxs[1] = max(nodestart[1], nodeend[1]) + 1; + sweepnodemaxs[2] = max(nodestart[2], nodeend[2]) + 1; + for (axis = 0;axis < BIH_MAXUNORDEREDCHILDREN && node->children[axis] >= 0;axis++) + { + leaf = bih->leafs + node->children[axis]; + if (!BoxesOverlap(sweepnodemins, sweepnodemaxs, leaf->mins, leaf->maxs)) + continue; + switch(leaf->type) + { + case BIH_BRUSH: + brush = model->brush.data_brushes[leaf->itemindex].colbrushf; + Collision_TraceLineBrushFloat(trace, start, end, brush, brush); + break; + case BIH_COLLISIONTRIANGLE: + if (!mod_q3bsp_curves_collisions.integer) + continue; + e = model->brush.data_collisionelement3i + 3*leaf->itemindex; + texture = model->data_textures + leaf->textureindex; + Collision_TraceLineTriangleFloat(trace, start, end, model->brush.data_collisionvertex3f + e[0] * 3, model->brush.data_collisionvertex3f + e[1] * 3, model->brush.data_collisionvertex3f + e[2] * 3, texture->supercontents, texture->surfaceflags, texture); + break; + case BIH_RENDERTRIANGLE: + e = model->surfmesh.data_element3i + 3*leaf->itemindex; + texture = model->data_textures + leaf->textureindex; + Collision_TraceLineTriangleFloat(trace, start, end, model->surfmesh.data_vertex3f + e[0] * 3, model->surfmesh.data_vertex3f + e[1] * 3, model->surfmesh.data_vertex3f + e[2] * 3, texture->supercontents, texture->surfaceflags, texture); + break; + } + } + } + } +} + +void Mod_CollisionBIH_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 skipsupercontentsmask, int skipmaterialflagsmask) +{ + if (VectorCompare(start, end)) + { + Mod_CollisionBIH_TracePoint(model, frameblend, skeleton, trace, start, hitsupercontentsmask, skipsupercontentsmask, skipmaterialflagsmask); + return; + } + Mod_CollisionBIH_TraceLineShared(model, frameblend, skeleton, trace, start, end, hitsupercontentsmask, skipsupercontentsmask, skipmaterialflagsmask, &model->collision_bih); +} + +void Mod_CollisionBIH_TraceBrush(dp_model_t *model, const frameblend_t *frameblend, const skeleton_t *skeleton, trace_t *trace, colbrushf_t *thisbrush_start, colbrushf_t *thisbrush_end, int hitsupercontentsmask, int skipsupercontentsmask, int skipmaterialflagsmask) +{ + const bih_t *bih; + const bih_leaf_t *leaf; + const bih_node_t *node; + const colbrushf_t *brush; + const int *e; + const texture_t *texture; + vec3_t start, end, startmins, startmaxs, endmins, endmaxs, mins, maxs; + vec3_t nodebigmins, nodebigmaxs, nodestart, nodeend, sweepnodemins, sweepnodemaxs; + vec_t d1, d2, d3, d4, f, nodestackline[1024][6]; + int axis, nodenum, nodestackpos = 0, nodestack[1024]; + + if (mod_q3bsp_optimizedtraceline.integer && VectorCompare(thisbrush_start->mins, thisbrush_start->maxs) && VectorCompare(thisbrush_end->mins, thisbrush_end->maxs)) + { + if (VectorCompare(thisbrush_start->mins, thisbrush_end->mins)) + Mod_CollisionBIH_TracePoint(model, frameblend, skeleton, trace, thisbrush_start->mins, hitsupercontentsmask, skipsupercontentsmask, skipmaterialflagsmask); + else + Mod_CollisionBIH_TraceLine(model, frameblend, skeleton, trace, thisbrush_start->mins, thisbrush_end->mins, hitsupercontentsmask, skipsupercontentsmask, skipmaterialflagsmask); + return; + } + + bih = &model->collision_bih; + if(!bih->nodes) + return; + nodenum = bih->rootnode; + + // box trace, performed as brush trace + memset(trace, 0, sizeof(*trace)); + trace->fraction = 1; + trace->hitsupercontentsmask = hitsupercontentsmask; + trace->skipsupercontentsmask = skipsupercontentsmask; + trace->skipmaterialflagsmask = skipmaterialflagsmask; + + // calculate tracebox-like parameters for efficient culling + VectorMAM(0.5f, thisbrush_start->mins, 0.5f, thisbrush_start->maxs, start); + VectorMAM(0.5f, thisbrush_end->mins, 0.5f, thisbrush_end->maxs, end); + VectorSubtract(thisbrush_start->mins, start, startmins); + VectorSubtract(thisbrush_start->maxs, start, startmaxs); + VectorSubtract(thisbrush_end->mins, end, endmins); + VectorSubtract(thisbrush_end->maxs, end, endmaxs); + mins[0] = min(startmins[0], endmins[0]); + mins[1] = min(startmins[1], endmins[1]); + mins[2] = min(startmins[2], endmins[2]); + maxs[0] = max(startmaxs[0], endmaxs[0]); + maxs[1] = max(startmaxs[1], endmaxs[1]); + maxs[2] = max(startmaxs[2], endmaxs[2]); + + // push first node + nodestackline[nodestackpos][0] = start[0]; + nodestackline[nodestackpos][1] = start[1]; + nodestackline[nodestackpos][2] = start[2]; + nodestackline[nodestackpos][3] = end[0]; + nodestackline[nodestackpos][4] = end[1]; + nodestackline[nodestackpos][5] = end[2]; + nodestack[nodestackpos++] = nodenum; + while (nodestackpos) + { + nodenum = nodestack[--nodestackpos]; + node = bih->nodes + nodenum; + VectorCopy(nodestackline[nodestackpos], nodestart); + VectorCopy(nodestackline[nodestackpos] + 3, nodeend); + sweepnodemins[0] = min(nodestart[0], nodeend[0]) + mins[0] - 1; + sweepnodemins[1] = min(nodestart[1], nodeend[1]) + mins[1] - 1; + sweepnodemins[2] = min(nodestart[2], nodeend[2]) + mins[2] - 1; + sweepnodemaxs[0] = max(nodestart[0], nodeend[0]) + maxs[0] + 1; + sweepnodemaxs[1] = max(nodestart[1], nodeend[1]) + maxs[1] + 1; + sweepnodemaxs[2] = max(nodestart[2], nodeend[2]) + maxs[2] + 1; + if (!BoxesOverlap(sweepnodemins, sweepnodemaxs, node->mins, node->maxs)) + continue; + if (node->type <= BIH_SPLITZ && nodestackpos+2 <= 1024) + { + // recurse children of the split + axis = node->type - BIH_SPLITX; + d1 = node->backmax - nodestart[axis] - mins[axis]; + d2 = node->backmax - nodeend[axis] - mins[axis]; + d3 = nodestart[axis] - node->frontmin + maxs[axis]; + d4 = nodeend[axis] - node->frontmin + maxs[axis]; + switch((d1 < 0) | ((d2 < 0) << 1) | ((d3 < 0) << 2) | ((d4 < 0) << 3)) + { + case 0: /* >>>> */ VectorCopy(nodestart, nodestackline[nodestackpos]); VectorCopy( nodeend, nodestackline[nodestackpos] + 3); nodestack[nodestackpos++] = node->back; VectorCopy(nodestart, nodestackline[nodestackpos]); VectorCopy( nodeend, nodestackline[nodestackpos] + 3); nodestack[nodestackpos++] = node->front; break; + case 1: /* <>>> */ f = d1 / (d1 - d2); VectorLerp(nodestart, f, nodeend, nodestackline[nodestackpos]); VectorCopy( nodeend, nodestackline[nodestackpos] + 3); nodestack[nodestackpos++] = node->back; VectorCopy(nodestart, nodestackline[nodestackpos]); VectorCopy( nodeend, nodestackline[nodestackpos] + 3); nodestack[nodestackpos++] = node->front; break; + case 2: /* ><>> */ f = d1 / (d1 - d2); VectorCopy(nodestart, nodestackline[nodestackpos]); VectorLerp(nodestart, f, nodeend, nodestackline[nodestackpos] + 3); nodestack[nodestackpos++] = node->back; VectorCopy(nodestart, nodestackline[nodestackpos]); VectorCopy( nodeend, nodestackline[nodestackpos] + 3); nodestack[nodestackpos++] = node->front; break; + case 3: /* <<>> */ VectorCopy(nodestart, nodestackline[nodestackpos]); VectorCopy( nodeend, nodestackline[nodestackpos] + 3); nodestack[nodestackpos++] = node->front; break; + case 4: /* >><> */ VectorCopy(nodestart, nodestackline[nodestackpos]); VectorCopy( nodeend, nodestackline[nodestackpos] + 3); nodestack[nodestackpos++] = node->back; f = d3 / (d3 - d4); VectorLerp(nodestart, f, nodeend, nodestackline[nodestackpos]); VectorCopy( nodeend, nodestackline[nodestackpos] + 3); nodestack[nodestackpos++] = node->front; break; + case 5: /* <><> */ f = d1 / (d1 - d2); VectorLerp(nodestart, f, nodeend, nodestackline[nodestackpos]); VectorCopy( nodeend, nodestackline[nodestackpos] + 3); nodestack[nodestackpos++] = node->back; f = d3 / (d3 - d4); VectorLerp(nodestart, f, nodeend, nodestackline[nodestackpos]); VectorCopy( nodeend, nodestackline[nodestackpos] + 3); nodestack[nodestackpos++] = node->front; break; + case 6: /* ><<> */ f = d1 / (d1 - d2); VectorCopy(nodestart, nodestackline[nodestackpos]); VectorLerp(nodestart, f, nodeend, nodestackline[nodestackpos] + 3); nodestack[nodestackpos++] = node->back; f = d3 / (d3 - d4); VectorLerp(nodestart, f, nodeend, nodestackline[nodestackpos]); VectorCopy( nodeend, nodestackline[nodestackpos] + 3); nodestack[nodestackpos++] = node->front; break; + case 7: /* <<<> */ f = d3 / (d3 - d4); VectorLerp(nodestart, f, nodeend, nodestackline[nodestackpos]); VectorCopy( nodeend, nodestackline[nodestackpos] + 3); nodestack[nodestackpos++] = node->front; break; + case 8: /* >>>< */ VectorCopy(nodestart, nodestackline[nodestackpos]); VectorCopy( nodeend, nodestackline[nodestackpos] + 3); nodestack[nodestackpos++] = node->back; f = d3 / (d3 - d4); VectorCopy(nodestart, nodestackline[nodestackpos]); VectorLerp(nodestart, f, nodeend, nodestackline[nodestackpos] + 3); nodestack[nodestackpos++] = node->front; break; + case 9: /* <>>< */ f = d1 / (d1 - d2); VectorLerp(nodestart, f, nodeend, nodestackline[nodestackpos]); VectorCopy( nodeend, nodestackline[nodestackpos] + 3); nodestack[nodestackpos++] = node->back; f = d3 / (d3 - d4); VectorCopy(nodestart, nodestackline[nodestackpos]); VectorLerp(nodestart, f, nodeend, nodestackline[nodestackpos] + 3); nodestack[nodestackpos++] = node->front; break; + case 10: /* ><>< */ f = d1 / (d1 - d2); VectorCopy(nodestart, nodestackline[nodestackpos]); VectorLerp(nodestart, f, nodeend, nodestackline[nodestackpos] + 3); nodestack[nodestackpos++] = node->back; f = d3 / (d3 - d4); VectorCopy(nodestart, nodestackline[nodestackpos]); VectorLerp(nodestart, f, nodeend, nodestackline[nodestackpos] + 3); nodestack[nodestackpos++] = node->front; break; + case 11: /* <<>< */ f = d3 / (d3 - d4); VectorCopy(nodestart, nodestackline[nodestackpos]); VectorLerp(nodestart, f, nodeend, nodestackline[nodestackpos] + 3); nodestack[nodestackpos++] = node->front; break; + case 12: /* >><< */ VectorCopy(nodestart, nodestackline[nodestackpos]); VectorCopy( nodeend, nodestackline[nodestackpos] + 3); nodestack[nodestackpos++] = node->back; break; + case 13: /* <><< */ f = d1 / (d1 - d2); VectorLerp(nodestart, f, nodeend, nodestackline[nodestackpos]); VectorCopy( nodeend, nodestackline[nodestackpos] + 3); nodestack[nodestackpos++] = node->back; break; + case 14: /* ><<< */ f = d1 / (d1 - d2); VectorCopy(nodestart, nodestackline[nodestackpos]); VectorLerp(nodestart, f, nodeend, nodestackline[nodestackpos] + 3); nodestack[nodestackpos++] = node->back; break; + case 15: /* <<<< */ break; + } + } + else if (node->type == BIH_UNORDERED) + { + // calculate sweep bounds for this node + // copy node bounds into local variables and expand to get Minkowski Sum of the two shapes + VectorSubtract(node->mins, maxs, nodebigmins); + VectorSubtract(node->maxs, mins, nodebigmaxs); + // clip line to this node bounds + axis = 0; d1 = nodestart[axis] - nodebigmins[axis]; d2 = nodeend[axis] - nodebigmins[axis]; if (d1 < 0) { if (d2 < 0) continue; f = d1 / (d1 - d2); VectorLerp(nodestart, f, nodeend, nodestart); } else if (d2 < 0) { f = d1 / (d1 - d2); VectorLerp(nodestart, f, nodeend, nodeend); } d1 = nodebigmaxs[axis] - nodestart[axis]; d2 = nodebigmaxs[axis] - nodeend[axis]; if (d1 < 0) { if (d2 < 0) continue; f = d1 / (d1 - d2); VectorLerp(nodestart, f, nodeend, nodestart); } else if (d2 < 0) { f = d1 / (d1 - d2); VectorLerp(nodestart, f, nodeend, nodeend); } + axis = 1; d1 = nodestart[axis] - nodebigmins[axis]; d2 = nodeend[axis] - nodebigmins[axis]; if (d1 < 0) { if (d2 < 0) continue; f = d1 / (d1 - d2); VectorLerp(nodestart, f, nodeend, nodestart); } else if (d2 < 0) { f = d1 / (d1 - d2); VectorLerp(nodestart, f, nodeend, nodeend); } d1 = nodebigmaxs[axis] - nodestart[axis]; d2 = nodebigmaxs[axis] - nodeend[axis]; if (d1 < 0) { if (d2 < 0) continue; f = d1 / (d1 - d2); VectorLerp(nodestart, f, nodeend, nodestart); } else if (d2 < 0) { f = d1 / (d1 - d2); VectorLerp(nodestart, f, nodeend, nodeend); } + axis = 2; d1 = nodestart[axis] - nodebigmins[axis]; d2 = nodeend[axis] - nodebigmins[axis]; if (d1 < 0) { if (d2 < 0) continue; f = d1 / (d1 - d2); VectorLerp(nodestart, f, nodeend, nodestart); } else if (d2 < 0) { f = d1 / (d1 - d2); VectorLerp(nodestart, f, nodeend, nodeend); } d1 = nodebigmaxs[axis] - nodestart[axis]; d2 = nodebigmaxs[axis] - nodeend[axis]; if (d1 < 0) { if (d2 < 0) continue; f = d1 / (d1 - d2); VectorLerp(nodestart, f, nodeend, nodestart); } else if (d2 < 0) { f = d1 / (d1 - d2); VectorLerp(nodestart, f, nodeend, nodeend); } + // some of the line intersected the enlarged node box + // calculate sweep bounds for this node + sweepnodemins[0] = min(nodestart[0], nodeend[0]) + mins[0] - 1; + sweepnodemins[1] = min(nodestart[1], nodeend[1]) + mins[1] - 1; + sweepnodemins[2] = min(nodestart[2], nodeend[2]) + mins[2] - 1; + sweepnodemaxs[0] = max(nodestart[0], nodeend[0]) + maxs[0] + 1; + sweepnodemaxs[1] = max(nodestart[1], nodeend[1]) + maxs[1] + 1; + sweepnodemaxs[2] = max(nodestart[2], nodeend[2]) + maxs[2] + 1; + for (axis = 0;axis < BIH_MAXUNORDEREDCHILDREN && node->children[axis] >= 0;axis++) + { + leaf = bih->leafs + node->children[axis]; + if (!BoxesOverlap(sweepnodemins, sweepnodemaxs, leaf->mins, leaf->maxs)) + continue; + switch(leaf->type) + { + case BIH_BRUSH: + brush = model->brush.data_brushes[leaf->itemindex].colbrushf; + Collision_TraceBrushBrushFloat(trace, thisbrush_start, thisbrush_end, brush, brush); + break; + case BIH_COLLISIONTRIANGLE: + if (!mod_q3bsp_curves_collisions.integer) + continue; + e = model->brush.data_collisionelement3i + 3*leaf->itemindex; + texture = model->data_textures + leaf->textureindex; + Collision_TraceBrushTriangleFloat(trace, thisbrush_start, thisbrush_end, model->brush.data_collisionvertex3f + e[0] * 3, model->brush.data_collisionvertex3f + e[1] * 3, model->brush.data_collisionvertex3f + e[2] * 3, texture->supercontents, texture->surfaceflags, texture); + break; + case BIH_RENDERTRIANGLE: + e = model->surfmesh.data_element3i + 3*leaf->itemindex; + texture = model->data_textures + leaf->textureindex; + Collision_TraceBrushTriangleFloat(trace, thisbrush_start, thisbrush_end, model->surfmesh.data_vertex3f + e[0] * 3, model->surfmesh.data_vertex3f + e[1] * 3, model->surfmesh.data_vertex3f + e[2] * 3, texture->supercontents, texture->surfaceflags, texture); + break; + } + } + } + } +} + +void Mod_CollisionBIH_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 skipsupercontentsmask, int skipmaterialflagsmask) +{ + colboxbrushf_t thisbrush_start, thisbrush_end; + vec3_t boxstartmins, boxstartmaxs, boxendmins, boxendmaxs; + + // box trace, performed as brush trace + 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); + Mod_CollisionBIH_TraceBrush(model, frameblend, skeleton, trace, &thisbrush_start.brush, &thisbrush_end.brush, hitsupercontentsmask, skipsupercontentsmask, skipmaterialflagsmask); +} + + +int Mod_CollisionBIH_PointSuperContents(struct model_s *model, int frame, const vec3_t point) +{ + trace_t trace; + Mod_CollisionBIH_TracePoint(model, NULL, NULL, &trace, point, 0, 0, 0); + return trace.startsupercontents; +} + +qboolean Mod_CollisionBIH_TraceLineOfSight(struct model_s *model, const vec3_t start, const vec3_t end, const vec3_t acceptmins, const vec3_t acceptmaxs) +{ + trace_t trace; + Mod_CollisionBIH_TraceLine(model, NULL, NULL, &trace, start, end, SUPERCONTENTS_VISBLOCKERMASK, 0, MATERIALFLAGMASK_TRANSLUCENT); + return trace.fraction == 1 || BoxesOverlap(trace.endpos, trace.endpos, acceptmins, acceptmaxs); +} + +void Mod_CollisionBIH_TracePoint_Mesh(dp_model_t *model, const frameblend_t *frameblend, const skeleton_t *skeleton, trace_t *trace, const vec3_t start, int hitsupercontentsmask, int skipsupercontentsmask, int skipmaterialflagsmask) +{ +#if 0 + // broken - needs to be modified to count front faces and backfaces to figure out if it is in solid + vec3_t end; + int hitsupercontents; + VectorSet(end, start[0], start[1], model->normalmins[2]); +#endif + memset(trace, 0, sizeof(*trace)); + trace->fraction = 1; + trace->hitsupercontentsmask = hitsupercontentsmask; + trace->skipsupercontentsmask = skipsupercontentsmask; + trace->skipmaterialflagsmask = skipmaterialflagsmask; +#if 0 + Mod_CollisionBIH_TraceLine(model, frameblend, skeleton, trace, start, end, hitsupercontentsmask, skipsupercontentsmask, skipmaterialflagsmask); + hitsupercontents = trace->hitsupercontents; + memset(trace, 0, sizeof(*trace)); + trace->fraction = 1; + trace->hitsupercontentsmask = hitsupercontentsmask; + trace->skipsupercontentsmask = skipsupercontentsmask; + trace->skipmaterialflagsmask = skipmaterialflagsmask; + trace->startsupercontents = hitsupercontents; +#endif +} + +int Mod_CollisionBIH_PointSuperContents_Mesh(struct model_s *model, int frame, const vec3_t start) +{ +#if 0 + // broken - needs to be modified to count front faces and backfaces to figure out if it is in solid + trace_t trace; + vec3_t end; + VectorSet(end, start[0], start[1], model->normalmins[2]); + memset(&trace, 0, sizeof(trace)); + trace.fraction = 1; + trace.hitsupercontentsmask = hitsupercontentsmask; + trace.skipsupercontentsmask = skipsupercontentsmask; + trace.skipmaterialflagsmask = skipmaterialflagsmask; + Mod_CollisionBIH_TraceLine(model, frameblend, skeleton, trace, start, end, hitsupercontentsmask, skipsupercontentsmask, skipmaterialflagsmask); + return trace.hitsupercontents; +#else + return 0; +#endif +} + static void Mod_Q3BSP_TracePoint_RecursiveBSPNode(trace_t *trace, dp_model_t *model, mnode_t *node, const vec3_t point, int markframe) { int i; @@ -5656,6 +7283,12 @@ static void Mod_Q3BSP_TraceLine_RecursiveBSPNode(trace_t *trace, dp_model_t *mod // walk the tree until we hit a leaf, recursing for any split cases while (node->plane) { +#if 0 + if (!BoxesOverlap(segmentmins, segmentmaxs, node->mins, node->maxs)) + return; + Mod_Q3BSP_TraceLine_RecursiveBSPNode(trace, model, node->children[0], start, end, startfrac, endfrac, linestart, lineend, markframe, segmentmins, segmentmaxs); + node = node->children[1]; +#else // abort if this part of the bsp tree can not be hit by this trace // if (!(node->combinedsupercontents & trace->hitsupercontentsmask)) // return; @@ -5690,10 +7323,11 @@ static void Mod_Q3BSP_TraceLine_RecursiveBSPNode(trace_t *trace, dp_model_t *mod Mod_Q3BSP_TraceLine_RecursiveBSPNode(trace, model, node->children[startside], start, mid, startfrac, midfrac, linestart, lineend, markframe, segmentmins, segmentmaxs); // if we found an impact on the front side, don't waste time // exploring the far side - if (midfrac <= trace->realfraction) + if (midfrac <= trace->fraction) Mod_Q3BSP_TraceLine_RecursiveBSPNode(trace, model, node->children[endside], mid, end, midfrac, endfrac, linestart, lineend, markframe, segmentmins, segmentmaxs); return; } +#endif } // abort if this part of the bsp tree can not be hit by this trace // if (!(node->combinedsupercontents & trace->hitsupercontentsmask)) @@ -5707,6 +7341,10 @@ static void Mod_Q3BSP_TraceLine_RecursiveBSPNode(trace_t *trace, dp_model_t *mod nodesegmentmaxs[2] = max(start[2], end[2]) + 1; // line trace the brushes leaf = (mleaf_t *)node; +#if 0 + if (!BoxesOverlap(segmentmins, segmentmaxs, leaf->mins, leaf->maxs)) + return; +#endif for (i = 0;i < leaf->numleafbrushes;i++) { brush = model->brush.data_brushes[leaf->firstleafbrush[i]].colbrushf; @@ -5723,10 +7361,10 @@ static void Mod_Q3BSP_TraceLine_RecursiveBSPNode(trace_t *trace, dp_model_t *mod for (i = 0;i < leaf->numleafsurfaces;i++) { surface = model->data_surfaces + leaf->firstleafsurface[i]; - if (surface->num_collisiontriangles && surface->collisionmarkframe != markframe && BoxesOverlap(nodesegmentmins, nodesegmentmaxs, surface->mins, surface->maxs)) + if (surface->num_collisiontriangles && surface->deprecatedq3collisionmarkframe != 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->num_collisionbboxstride, surface->data_collisionbbox6f, surface->texture->supercontents, surface->texture->surfaceflags, surface->texture, segmentmins, segmentmaxs); + surface->deprecatedq3collisionmarkframe = markframe; + Collision_TraceLineTriangleMeshFloat(trace, linestart, lineend, surface->num_collisiontriangles, surface->deprecatedq3data_collisionelement3i, surface->deprecatedq3data_collisionvertex3f, surface->deprecatedq3num_collisionbboxstride, surface->deprecatedq3data_collisionbbox6f, surface->texture->supercontents, surface->texture->surfaceflags, surface->texture, segmentmins, segmentmaxs); } } } @@ -5744,6 +7382,12 @@ static void Mod_Q3BSP_TraceBrush_RecursiveBSPNode(trace_t *trace, dp_model_t *mo // walk the tree until we hit a leaf, recursing for any split cases while (node->plane) { +#if 0 + if (!BoxesOverlap(segmentmins, segmentmaxs, node->mins, node->maxs)) + return; + Mod_Q3BSP_TraceBrush_RecursiveBSPNode(trace, model, node->children[0], thisbrush_start, thisbrush_end, markframe, segmentmins, segmentmaxs); + node = node->children[1]; +#else // abort if this part of the bsp tree can not be hit by this trace // if (!(node->combinedsupercontents & trace->hitsupercontentsmask)) // return; @@ -5778,6 +7422,7 @@ static void Mod_Q3BSP_TraceBrush_RecursiveBSPNode(trace_t *trace, dp_model_t *mo return; // ERROR: NAN bounding box! // take whichever side the segment box is on node = node->children[sides - 1]; +#endif } // abort if this part of the bsp tree can not be hit by this trace // if (!(node->combinedsupercontents & trace->hitsupercontentsmask)) @@ -5790,6 +7435,10 @@ static void Mod_Q3BSP_TraceBrush_RecursiveBSPNode(trace_t *trace, dp_model_t *mo nodesegmentmaxs[2] = min(segmentmaxs[2], node->maxs[2] + 1); // hit a leaf leaf = (mleaf_t *)node; +#if 0 + if (!BoxesOverlap(segmentmins, segmentmaxs, leaf->mins, leaf->maxs)) + return; +#endif for (i = 0;i < leaf->numleafbrushes;i++) { brush = model->brush.data_brushes[leaf->firstleafbrush[i]].colbrushf; @@ -5804,26 +7453,30 @@ static void Mod_Q3BSP_TraceBrush_RecursiveBSPNode(trace_t *trace, dp_model_t *mo for (i = 0;i < leaf->numleafsurfaces;i++) { surface = model->data_surfaces + leaf->firstleafsurface[i]; - if (surface->num_collisiontriangles && surface->collisionmarkframe != markframe && BoxesOverlap(nodesegmentmins, nodesegmentmaxs, surface->mins, surface->maxs)) + if (surface->num_collisiontriangles && surface->deprecatedq3collisionmarkframe != 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->num_collisionbboxstride, surface->data_collisionbbox6f, surface->texture->supercontents, surface->texture->surfaceflags, surface->texture, segmentmins, segmentmaxs); + surface->deprecatedq3collisionmarkframe = markframe; + Collision_TraceBrushTriangleMeshFloat(trace, thisbrush_start, thisbrush_end, surface->num_collisiontriangles, surface->deprecatedq3data_collisionelement3i, surface->deprecatedq3data_collisionvertex3f, surface->deprecatedq3num_collisionbboxstride, surface->deprecatedq3data_collisionbbox6f, surface->texture->supercontents, surface->texture->surfaceflags, surface->texture, segmentmins, segmentmaxs); } } } } + static int markframe = 0; -static void Mod_Q3BSP_TracePoint(dp_model_t *model, int frame, trace_t *trace, const vec3_t start, int hitsupercontentsmask) +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 skipsupercontentsmask, int skipmaterialflagsmask) { int i; q3mbrush_t *brush; memset(trace, 0, sizeof(*trace)); trace->fraction = 1; - trace->realfraction = 1; trace->hitsupercontentsmask = hitsupercontentsmask; - if (model->brush.submodel) + trace->skipsupercontentsmask = skipsupercontentsmask; + trace->skipmaterialflagsmask = skipmaterialflagsmask; + if (mod_collision_bih.integer) + Mod_CollisionBIH_TracePoint(model, frameblend, skeleton, trace, start, hitsupercontentsmask, skipsupercontentsmask, skipmaterialflagsmask); + else if (model->brush.submodel) { for (i = 0, brush = model->brush.data_brushes + model->firstmodelbrush;i < model->nummodelbrushes;i++, brush++) if (brush->colbrushf) @@ -5833,7 +7486,7 @@ static void Mod_Q3BSP_TracePoint(dp_model_t *model, int frame, trace_t *trace, c Mod_Q3BSP_TracePoint_RecursiveBSPNode(trace, model, model->brush.data_nodes, start, ++markframe); } -static void Mod_Q3BSP_TraceLine(dp_model_t *model, int frame, trace_t *trace, const vec3_t start, const vec3_t end, int hitsupercontentsmask) +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 skipsupercontentsmask, int skipmaterialflagsmask) { int i; float segmentmins[3], segmentmaxs[3]; @@ -5842,87 +7495,94 @@ static void Mod_Q3BSP_TraceLine(dp_model_t *model, int frame, trace_t *trace, co if (VectorCompare(start, end)) { - Mod_Q3BSP_TracePoint(model, frame, trace, start, hitsupercontentsmask); + Mod_Q3BSP_TracePoint(model, frameblend, skeleton, trace, start, hitsupercontentsmask, skipsupercontentsmask, skipmaterialflagsmask); return; } memset(trace, 0, sizeof(*trace)); trace->fraction = 1; - trace->realfraction = 1; trace->hitsupercontentsmask = hitsupercontentsmask; + trace->skipsupercontentsmask = skipsupercontentsmask; + trace->skipmaterialflagsmask = skipmaterialflagsmask; 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) + if (mod_collision_bih.integer) + Mod_CollisionBIH_TraceLine(model, frameblend, skeleton, trace, start, end, hitsupercontentsmask, skipsupercontentsmask, skipmaterialflagsmask); + else if (model->brush.submodel) { for (i = 0, brush = model->brush.data_brushes + model->firstmodelbrush;i < model->nummodelbrushes;i++, brush++) - if (brush->colbrushf) + if (brush->colbrushf && BoxesOverlap(segmentmins, segmentmaxs, brush->colbrushf->mins, brush->colbrushf->maxs)) 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); + if (surface->num_collisiontriangles && BoxesOverlap(segmentmins, segmentmaxs, surface->mins, surface->maxs)) + Collision_TraceLineTriangleMeshFloat(trace, start, end, surface->num_collisiontriangles, surface->deprecatedq3data_collisionelement3i, surface->deprecatedq3data_collisionvertex3f, surface->deprecatedq3num_collisionbboxstride, surface->deprecatedq3data_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, int frame, trace_t *trace, const vec3_t start, const vec3_t boxmins, const vec3_t boxmaxs, const vec3_t end, int hitsupercontentsmask) +static void Mod_Q3BSP_TraceBrush(dp_model_t *model, const frameblend_t *frameblend, const skeleton_t *skeleton, trace_t *trace, colbrushf_t *start, colbrushf_t *end, int hitsupercontentsmask, int skipsupercontentsmask, int skipmaterialflagsmask) { - int i; float segmentmins[3], segmentmaxs[3]; + int i; msurface_t *surface; q3mbrush_t *brush; - colbrushf_t *thisbrush_start, *thisbrush_end; - vec3_t boxstartmins, boxstartmaxs, boxendmins, boxendmaxs; - if (mod_q3bsp_optimizedtraceline.integer && VectorCompare(boxmins, boxmaxs)) + if (mod_q3bsp_optimizedtraceline.integer && VectorCompare(start->mins, start->maxs) && VectorCompare(end->mins, end->maxs)) { - vec3_t shiftstart, shiftend; - VectorAdd(start, boxmins, shiftstart); - VectorAdd(end, boxmins, shiftend); - if (VectorCompare(start, end)) - Mod_Q3BSP_TracePoint(model, frame, trace, shiftstart, hitsupercontentsmask); + if (VectorCompare(start->mins, end->mins)) + Mod_Q3BSP_TracePoint(model, frameblend, skeleton, trace, start->mins, hitsupercontentsmask, skipsupercontentsmask, skipmaterialflagsmask); else - { - Mod_Q3BSP_TraceLine(model, frame, trace, shiftstart, shiftend, hitsupercontentsmask); - VectorSubtract(trace->endpos, boxmins, trace->endpos); - } + Mod_Q3BSP_TraceLine(model, frameblend, skeleton, trace, start->mins, end->mins, hitsupercontentsmask, skipsupercontentsmask, skipmaterialflagsmask); 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); - thisbrush_start = Collision_BrushForBox(&identitymatrix, boxstartmins, boxstartmaxs, 0, 0, NULL); - thisbrush_end = Collision_BrushForBox(&identitymatrix, boxendmins, boxendmaxs, 0, 0, NULL); - if (model->brush.submodel) + trace->skipsupercontentsmask = skipsupercontentsmask; + trace->skipmaterialflagsmask = skipmaterialflagsmask; + segmentmins[0] = min(start->mins[0], end->mins[0]) - 1; + segmentmins[1] = min(start->mins[1], end->mins[1]) - 1; + segmentmins[2] = min(start->mins[2], end->mins[2]) - 1; + segmentmaxs[0] = max(start->maxs[0], end->maxs[0]) + 1; + segmentmaxs[1] = max(start->maxs[1], end->maxs[1]) + 1; + segmentmaxs[2] = max(start->maxs[2], end->maxs[2]) + 1; + if (mod_collision_bih.integer) + Mod_CollisionBIH_TraceBrush(model, frameblend, skeleton, trace, start, end, hitsupercontentsmask, skipsupercontentsmask, skipmaterialflagsmask); + else 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 (brush->colbrushf && BoxesOverlap(segmentmins, segmentmaxs, brush->colbrushf->mins, brush->colbrushf->maxs)) + Collision_TraceBrushBrushFloat(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_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); + if (surface->num_collisiontriangles && BoxesOverlap(segmentmins, segmentmaxs, surface->mins, surface->maxs)) + Collision_TraceBrushTriangleMeshFloat(trace, start, end, surface->num_collisiontriangles, surface->deprecatedq3data_collisionelement3i, surface->deprecatedq3data_collisionvertex3f, surface->deprecatedq3num_collisionbboxstride, surface->deprecatedq3data_collisionbbox6f, surface->texture->supercontents, surface->texture->surfaceflags, surface->texture, segmentmins, segmentmaxs); } else - Mod_Q3BSP_TraceBrush_RecursiveBSPNode(trace, model, model->brush.data_nodes, thisbrush_start, thisbrush_end, ++markframe, segmentmins, segmentmaxs); + Mod_Q3BSP_TraceBrush_RecursiveBSPNode(trace, model, model->brush.data_nodes, 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 skipsupercontentsmask, int skipmaterialflagsmask) +{ + colboxbrushf_t thisbrush_start, thisbrush_end; + vec3_t boxstartmins, boxstartmaxs, boxendmins, boxendmaxs; + + // box trace, performed as brush trace + 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); + Mod_Q3BSP_TraceBrush(model, frameblend, skeleton, trace, &thisbrush_start.brush, &thisbrush_end.brush, hitsupercontentsmask, skipsupercontentsmask, skipmaterialflagsmask); } static int Mod_Q3BSP_PointSuperContents(struct model_s *model, int frame, const vec3_t point) @@ -5930,8 +7590,12 @@ static int Mod_Q3BSP_PointSuperContents(struct model_s *model, int frame, const int i; int supercontents = 0; q3mbrush_t *brush; + if (mod_collision_bih.integer) + { + supercontents = Mod_CollisionBIH_PointSuperContents(model, frame, point); + } // test if the point is inside each brush - if (model->brush.submodel) + else if (model->brush.submodel) { // submodels are effectively one leaf for (i = 0, brush = model->brush.data_brushes + model->firstmodelbrush;i < model->nummodelbrushes;i++, brush++) @@ -5957,7 +7621,148 @@ static int Mod_Q3BSP_PointSuperContents(struct model_s *model, int frame, const return supercontents; } -static int Mod_Q3BSP_SuperContentsFromNativeContents(dp_model_t *model, int nativecontents) +void Mod_CollisionBIH_TraceLineAgainstSurfaces(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 skipsupercontentsmask, int skipmaterialflagsmask) +{ + Mod_CollisionBIH_TraceLineShared(model, frameblend, skeleton, trace, start, end, hitsupercontentsmask, skipsupercontentsmask, skipmaterialflagsmask, &model->render_bih); +} + + +bih_t *Mod_MakeCollisionBIH(dp_model_t *model, qboolean userendersurfaces, bih_t *out) +{ + int j; + int bihnumleafs; + int bihmaxnodes; + int brushindex; + int triangleindex; + int bihleafindex; + int nummodelbrushes = model->nummodelbrushes; + int nummodelsurfaces = model->nummodelsurfaces; + const int *e; + const int *collisionelement3i; + const float *collisionvertex3f; + const int *renderelement3i; + const float *rendervertex3f; + bih_leaf_t *bihleafs; + bih_node_t *bihnodes; + int *temp_leafsort; + int *temp_leafsortscratch; + const msurface_t *surface; + const q3mbrush_t *brush; + + // find out how many BIH leaf nodes we need + bihnumleafs = 0; + if (userendersurfaces) + { + for (j = 0, surface = model->data_surfaces + model->firstmodelsurface;j < nummodelsurfaces;j++, surface++) + bihnumleafs += surface->num_triangles; + } + else + { + for (brushindex = 0, brush = model->brush.data_brushes + brushindex+model->firstmodelbrush;brushindex < nummodelbrushes;brushindex++, brush++) + if (brush->colbrushf) + bihnumleafs++; + for (j = 0, surface = model->data_surfaces + model->firstmodelsurface;j < nummodelsurfaces;j++, surface++) + { + if (surface->texture->basematerialflags & MATERIALFLAG_MESHCOLLISIONS) + bihnumleafs += surface->num_triangles + surface->num_collisiontriangles; + else + bihnumleafs += surface->num_collisiontriangles; + } + } + + if (!bihnumleafs) + return NULL; + + // allocate the memory for the BIH leaf nodes + bihleafs = (bih_leaf_t *)Mem_Alloc(loadmodel->mempool, sizeof(bih_leaf_t) * bihnumleafs); + + // now populate the BIH leaf nodes + bihleafindex = 0; + + // add render surfaces + renderelement3i = model->surfmesh.data_element3i; + rendervertex3f = model->surfmesh.data_vertex3f; + for (j = 0, surface = model->data_surfaces + model->firstmodelsurface;j < nummodelsurfaces;j++, surface++) + { + for (triangleindex = 0, e = renderelement3i + 3*surface->num_firsttriangle;triangleindex < surface->num_triangles;triangleindex++, e += 3) + { + if (!userendersurfaces && !(surface->texture->basematerialflags & MATERIALFLAG_MESHCOLLISIONS)) + continue; + bihleafs[bihleafindex].type = BIH_RENDERTRIANGLE; + bihleafs[bihleafindex].textureindex = surface->texture - model->data_textures; + bihleafs[bihleafindex].surfaceindex = surface - model->data_surfaces; + bihleafs[bihleafindex].itemindex = triangleindex+surface->num_firsttriangle; + bihleafs[bihleafindex].mins[0] = min(rendervertex3f[3*e[0]+0], min(rendervertex3f[3*e[1]+0], rendervertex3f[3*e[2]+0])) - 1; + bihleafs[bihleafindex].mins[1] = min(rendervertex3f[3*e[0]+1], min(rendervertex3f[3*e[1]+1], rendervertex3f[3*e[2]+1])) - 1; + bihleafs[bihleafindex].mins[2] = min(rendervertex3f[3*e[0]+2], min(rendervertex3f[3*e[1]+2], rendervertex3f[3*e[2]+2])) - 1; + bihleafs[bihleafindex].maxs[0] = max(rendervertex3f[3*e[0]+0], max(rendervertex3f[3*e[1]+0], rendervertex3f[3*e[2]+0])) + 1; + bihleafs[bihleafindex].maxs[1] = max(rendervertex3f[3*e[0]+1], max(rendervertex3f[3*e[1]+1], rendervertex3f[3*e[2]+1])) + 1; + bihleafs[bihleafindex].maxs[2] = max(rendervertex3f[3*e[0]+2], max(rendervertex3f[3*e[1]+2], rendervertex3f[3*e[2]+2])) + 1; + bihleafindex++; + } + } + + if (!userendersurfaces) + { + // add collision brushes + for (brushindex = 0, brush = model->brush.data_brushes + brushindex+model->firstmodelbrush;brushindex < nummodelbrushes;brushindex++, brush++) + { + if (!brush->colbrushf) + continue; + bihleafs[bihleafindex].type = BIH_BRUSH; + bihleafs[bihleafindex].textureindex = brush->texture - model->data_textures; + bihleafs[bihleafindex].surfaceindex = -1; + bihleafs[bihleafindex].itemindex = brushindex+model->firstmodelbrush; + VectorCopy(brush->colbrushf->mins, bihleafs[bihleafindex].mins); + VectorCopy(brush->colbrushf->maxs, bihleafs[bihleafindex].maxs); + bihleafindex++; + } + + // add collision surfaces + collisionelement3i = model->brush.data_collisionelement3i; + collisionvertex3f = model->brush.data_collisionvertex3f; + for (j = 0, surface = model->data_surfaces + model->firstmodelsurface;j < nummodelsurfaces;j++, surface++) + { + for (triangleindex = 0, e = collisionelement3i + 3*surface->num_firstcollisiontriangle;triangleindex < surface->num_collisiontriangles;triangleindex++, e += 3) + { + bihleafs[bihleafindex].type = BIH_COLLISIONTRIANGLE; + bihleafs[bihleafindex].textureindex = surface->texture - model->data_textures; + bihleafs[bihleafindex].surfaceindex = surface - model->data_surfaces; + bihleafs[bihleafindex].itemindex = triangleindex+surface->num_firstcollisiontriangle; + bihleafs[bihleafindex].mins[0] = min(collisionvertex3f[3*e[0]+0], min(collisionvertex3f[3*e[1]+0], collisionvertex3f[3*e[2]+0])) - 1; + bihleafs[bihleafindex].mins[1] = min(collisionvertex3f[3*e[0]+1], min(collisionvertex3f[3*e[1]+1], collisionvertex3f[3*e[2]+1])) - 1; + bihleafs[bihleafindex].mins[2] = min(collisionvertex3f[3*e[0]+2], min(collisionvertex3f[3*e[1]+2], collisionvertex3f[3*e[2]+2])) - 1; + bihleafs[bihleafindex].maxs[0] = max(collisionvertex3f[3*e[0]+0], max(collisionvertex3f[3*e[1]+0], collisionvertex3f[3*e[2]+0])) + 1; + bihleafs[bihleafindex].maxs[1] = max(collisionvertex3f[3*e[0]+1], max(collisionvertex3f[3*e[1]+1], collisionvertex3f[3*e[2]+1])) + 1; + bihleafs[bihleafindex].maxs[2] = max(collisionvertex3f[3*e[0]+2], max(collisionvertex3f[3*e[1]+2], collisionvertex3f[3*e[2]+2])) + 1; + bihleafindex++; + } + } + } + + // allocate buffers for the produced and temporary data + bihmaxnodes = bihnumleafs + 1; + bihnodes = (bih_node_t *)Mem_Alloc(loadmodel->mempool, sizeof(bih_node_t) * bihmaxnodes); + temp_leafsort = (int *)Mem_Alloc(loadmodel->mempool, sizeof(int) * bihnumleafs * 2); + temp_leafsortscratch = temp_leafsort + bihnumleafs; + + // now build it + BIH_Build(out, bihnumleafs, bihleafs, bihmaxnodes, bihnodes, temp_leafsort, temp_leafsortscratch); + + // we're done with the temporary data + Mem_Free(temp_leafsort); + + // resize the BIH nodes array if it over-allocated + if (out->maxnodes > out->numnodes) + { + out->maxnodes = out->numnodes; + out->nodes = (bih_node_t *)Mem_Realloc(loadmodel->mempool, out->nodes, out->numnodes * sizeof(bih_node_t)); + } + + return out; +} + +static int Mod_Q3BSP_SuperContentsFromNativeContents(int nativecontents) { int supercontents = 0; if (nativecontents & CONTENTSQ3_SOLID) @@ -5987,7 +7792,7 @@ static int Mod_Q3BSP_SuperContentsFromNativeContents(dp_model_t *model, int nati return supercontents; } -static int Mod_Q3BSP_NativeContentsFromSuperContents(dp_model_t *model, int supercontents) +static int Mod_Q3BSP_NativeContentsFromSuperContents(int supercontents) { int nativecontents = 0; if (supercontents & SUPERCONTENTS_SOLID) @@ -6017,7 +7822,7 @@ static int Mod_Q3BSP_NativeContentsFromSuperContents(dp_model_t *model, int supe return nativecontents; } -void Mod_Q3BSP_RecursiveFindNumLeafs(mnode_t *node) +static void Mod_Q3BSP_RecursiveFindNumLeafs(mnode_t *node) { int numleafs; while (node->plane) @@ -6030,16 +7835,21 @@ void Mod_Q3BSP_RecursiveFindNumLeafs(mnode_t *node) loadmodel->brush.num_leafs = numleafs; } -void Mod_Q3BSP_Load(dp_model_t *mod, void *buffer, void *bufferend) +static void Mod_Q3BSP_Load(dp_model_t *mod, void *buffer, void *bufferend) { - int i, j, numshadowmeshtriangles, lumps; + int i, j, lumps; q3dheader_t *header; float corner[3], yawradius, modelradius; - msurface_t *surface; mod->modeldatatypestring = "Q3BSP"; mod->type = mod_brushq3; + mod->brush.ishlbsp = false; + mod->brush.isbsp2rmqe = false; + mod->brush.isbsp2 = false; + mod->brush.isq2bsp = false; + mod->brush.isq3bsp = true; + mod->brush.skymasking = true; mod->numframes = 2; // although alternate textures are not supported it is annoying to complain about no such frame 1 mod->numskins = 1; @@ -6053,10 +7863,12 @@ void Mod_Q3BSP_Load(dp_model_t *mod, void *buffer, void *bufferend) mod->soundfromcenter = true; mod->TraceBox = Mod_Q3BSP_TraceBox; + mod->TraceBrush = Mod_Q3BSP_TraceBrush; mod->TraceLine = Mod_Q3BSP_TraceLine; mod->TracePoint = Mod_Q3BSP_TracePoint; mod->PointSuperContents = Mod_Q3BSP_PointSuperContents; - mod->brush.TraceLineOfSight = Mod_Q1BSP_TraceLineOfSight; + mod->TraceLineAgainstSurfaces = Mod_CollisionBIH_TraceLine; + mod->brush.TraceLineOfSight = Mod_Q3BSP_TraceLineOfSight; mod->brush.SuperContentsFromNativeContents = Mod_Q3BSP_SuperContentsFromNativeContents; mod->brush.NativeContentsFromSuperContents = Mod_Q3BSP_NativeContentsFromSuperContents; mod->brush.GetPVS = Mod_Q1BSP_GetPVS; @@ -6073,11 +7885,10 @@ void Mod_Q3BSP_Load(dp_model_t *mod, void *buffer, void *bufferend) 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_base = (unsigned char *)header; @@ -6146,31 +7957,18 @@ void Mod_Q3BSP_Load(dp_model_t *mod, void *buffer, void *bufferend) loadmodel->brush.numsubmodels = loadmodel->brushq3.num_models; // the MakePortals code works fine on the q3bsp data as well - Mod_Q1BSP_MakePortals(); + if (mod_bsp_portalize.integer) + Mod_Q1BSP_MakePortals(); // FIXME: shader alpha should replace r_wateralpha support in q3bsp loadmodel->brush.supportwateralpha = true; - // make a single combined shadow mesh to allow optimized shadow volume creation - numshadowmeshtriangles = 0; - if (cls.state != ca_dedicated) - { - 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.num_leafs = 0; Mod_Q3BSP_RecursiveFindNumLeafs(loadmodel->brush.data_nodes); + 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++) { @@ -6188,7 +7986,6 @@ void Mod_Q3BSP_Load(dp_model_t *mod, void *buffer, void *bufferend) // 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; @@ -6199,6 +7996,8 @@ void Mod_Q3BSP_Load(dp_model_t *mod, void *buffer, void *bufferend) 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; @@ -6259,11 +8058,44 @@ void Mod_Q3BSP_Load(dp_model_t *mod, void *buffer, void *bufferend) mod->DrawSky = R_Q1BSP_DrawSky; for (j = 0;j < mod->nummodelsurfaces;j++) - if (mod->data_surfaces[j + mod->firstmodelsurface].texture->basematerialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION | MATERIALFLAG_REFLECTION)) + if (mod->data_surfaces[j + mod->firstmodelsurface].texture->basematerialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION | MATERIALFLAG_REFLECTION | MATERIALFLAG_CAMERA)) break; if (j < mod->nummodelsurfaces) mod->DrawAddWaterPlanes = R_Q1BSP_DrawAddWaterPlanes; + + Mod_MakeCollisionBIH(mod, false, &mod->collision_bih); + Mod_MakeCollisionBIH(mod, true, &mod->render_bih); + + // generate VBOs and other shared data before cloning submodels + if (i == 0) + Mod_BuildVBOs(); + } + + if (mod_q3bsp_sRGBlightmaps.integer) + { + if (vid_sRGB.integer && vid_sRGB_fallback.integer && !vid.sRGB3D) + { + // actually we do in sRGB fallback with sRGB lightmaps: Image_sRGBFloatFromLinear_Lightmap(Image_LinearFloatFromsRGBFloat(x)) + // neutral point is at Image_sRGBFloatFromLinearFloat(0.5) + // so we need to map Image_sRGBFloatFromLinearFloat(0.5) to 0.5 + // factor is 0.5 / Image_sRGBFloatFromLinearFloat(0.5) + //loadmodel->lightmapscale *= 0.679942f; // fixes neutral level + } + else // if this is NOT set, regular rendering looks right by this requirement anyway + { + /* + // we want color 1 to do the same as without sRGB + // so, we want to map 1 to Image_LinearFloatFromsRGBFloat(2) instead of to 2 + loadmodel->lightmapscale *= 2.476923f; // fixes max level + */ + + // neutral level 0.5 gets uploaded as sRGB and becomes Image_LinearFloatFromsRGBFloat(0.5) + // we need to undo that + loadmodel->lightmapscale *= 2.336f; // fixes neutral level + } } + + Con_DPrintf("Stats for q3bsp model \"%s\": %i faces, %i nodes, %i leafs, %i clusters, %i clusterportals, mesh: %i vertices, %i triangles, %i surfaces\n", loadmodel->name, loadmodel->num_surfaces, loadmodel->brush.num_nodes, loadmodel->brush.num_leafs, mod->brush.num_pvsclusters, loadmodel->brush.num_portals, loadmodel->surfmesh.num_vertices, loadmodel->surfmesh.num_triangles, loadmodel->num_surfaces); } void Mod_IBSP_Load(dp_model_t *mod, void *buffer, void *bufferend) @@ -6282,39 +8114,611 @@ void Mod_MAP_Load(dp_model_t *mod, void *buffer, void *bufferend) Host_Error("Mod_MAP_Load: not yet implemented"); } -qboolean Mod_CanSeeBox_Trace(int numsamples, float t, dp_model_t *model, vec3_t eye, vec3_t minsX, vec3_t maxsX) +typedef struct objvertex_s { - // we already have done PVS culling at this point... - // so we don't need to do it again. + int nextindex; + int submodelindex; + int textureindex; + float v[3]; + float vt[2]; + float vn[3]; +} +objvertex_t; - int i; - vec3_t testorigin, mins, maxs; +static unsigned char nobsp_pvs[1] = {1}; - testorigin[0] = (minsX[0] + maxsX[0]) * 0.5; - testorigin[1] = (minsX[1] + maxsX[1]) * 0.5; - testorigin[2] = (minsX[2] + maxsX[2]) * 0.5; +void Mod_OBJ_Load(dp_model_t *mod, void *buffer, void *bufferend) +{ + const char *textbase = (char *)buffer, *text = textbase; + char *s; + char *argv[512]; + char line[1024]; + char materialname[MAX_QPATH]; + int i, j, l, numvertices, firstvertex, firsttriangle, elementindex, vertexindex, surfacevertices, surfacetriangles, surfaceelements, submodelindex = 0; + int index1, index2, index3; + objvertex_t vfirst, vprev, vcurrent; + int argc; + int linelen; + int numtriangles = 0; + int maxtriangles = 0; + objvertex_t *vertices = NULL; + int linenumber = 0; + int maxtextures = 0, numtextures = 0, textureindex = 0; + int maxv = 0, numv = 1; + int maxvt = 0, numvt = 1; + int maxvn = 0, numvn = 1; + char *texturenames = NULL; + float dist, modelradius, modelyawradius, yawradius; + float *obj_v = NULL; + float *obj_vt = NULL; + float *obj_vn = NULL; + float mins[3]; + float maxs[3]; + float corner[3]; + objvertex_t *thisvertex = NULL; + int vertexhashindex; + int *vertexhashtable = NULL; + objvertex_t *vertexhashdata = NULL; + objvertex_t *vdata = NULL; + int vertexhashsize = 0; + int vertexhashcount = 0; + skinfile_t *skinfiles = NULL; + unsigned char *data = NULL; + int *submodelfirstsurface; + msurface_t *tempsurface; + msurface_t *tempsurfaces; + + memset(&vfirst, 0, sizeof(vfirst)); + memset(&vprev, 0, sizeof(vprev)); + memset(&vcurrent, 0, sizeof(vcurrent)); + + dpsnprintf(materialname, sizeof(materialname), "%s", loadmodel->name); + + loadmodel->modeldatatypestring = "OBJ"; + + loadmodel->type = mod_obj; + loadmodel->soundfromcenter = true; + loadmodel->TraceBox = Mod_CollisionBIH_TraceBox; + loadmodel->TraceBrush = Mod_CollisionBIH_TraceBrush; + loadmodel->TraceLine = Mod_CollisionBIH_TraceLine; + loadmodel->TracePoint = Mod_CollisionBIH_TracePoint_Mesh; + loadmodel->TraceLineAgainstSurfaces = Mod_CollisionBIH_TraceLine; + loadmodel->PointSuperContents = Mod_CollisionBIH_PointSuperContents_Mesh; + loadmodel->brush.TraceLineOfSight = NULL; + loadmodel->brush.SuperContentsFromNativeContents = NULL; + loadmodel->brush.NativeContentsFromSuperContents = NULL; + loadmodel->brush.GetPVS = NULL; + loadmodel->brush.FatPVS = NULL; + loadmodel->brush.BoxTouchingPVS = NULL; + loadmodel->brush.BoxTouchingLeafPVS = NULL; + loadmodel->brush.BoxTouchingVisibleLeafs = NULL; + loadmodel->brush.FindBoxClusters = NULL; + loadmodel->brush.LightPoint = NULL; + loadmodel->brush.FindNonSolidLocation = NULL; + loadmodel->brush.AmbientSoundLevelsForPoint = NULL; + loadmodel->brush.RoundUpToHullSize = NULL; + loadmodel->brush.PointInLeaf = NULL; + 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->DrawLight = R_Q1BSP_DrawLight; + + skinfiles = Mod_LoadSkinFiles(); + if (loadmodel->numskins < 1) + loadmodel->numskins = 1; + + // make skinscenes for the skins (no groups) + 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; + } + + VectorClear(mins); + VectorClear(maxs); + + // we always have model 0, i.e. the first "submodel" + loadmodel->brush.numsubmodels = 1; + + // parse the OBJ text now + for(;;) + { + static char emptyarg[1] = ""; + 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 < 4;argc++) + argv[argc] = emptyarg; + 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++; + } + text += linelen; + if (*text == '\r') + text++; + if (*text == '\n') + text++; + if (!argc) + continue; + if (argv[0][0] == '#') + continue; + if (!strcmp(argv[0], "v")) + { + if (maxv <= numv) + { + maxv = max(maxv * 2, 1024); + obj_v = (float *)Mem_Realloc(tempmempool, obj_v, maxv * sizeof(float[3])); + } + if(mod_obj_orientation.integer) + { + obj_v[numv*3+0] = atof(argv[1]); + obj_v[numv*3+2] = atof(argv[2]); + obj_v[numv*3+1] = atof(argv[3]); + } + else + { + obj_v[numv*3+0] = atof(argv[1]); + obj_v[numv*3+1] = atof(argv[2]); + obj_v[numv*3+2] = atof(argv[3]); + } + numv++; + } + else if (!strcmp(argv[0], "vt")) + { + if (maxvt <= numvt) + { + maxvt = max(maxvt * 2, 1024); + obj_vt = (float *)Mem_Realloc(tempmempool, obj_vt, maxvt * sizeof(float[2])); + } + obj_vt[numvt*2+0] = atof(argv[1]); + obj_vt[numvt*2+1] = 1-atof(argv[2]); + numvt++; + } + else if (!strcmp(argv[0], "vn")) + { + if (maxvn <= numvn) + { + maxvn = max(maxvn * 2, 1024); + obj_vn = (float *)Mem_Realloc(tempmempool, obj_vn, maxvn * sizeof(float[3])); + } + if(mod_obj_orientation.integer) + { + obj_vn[numvn*3+0] = atof(argv[1]); + obj_vn[numvn*3+2] = atof(argv[2]); + obj_vn[numvn*3+1] = atof(argv[3]); + } + else + { + obj_vn[numvn*3+0] = atof(argv[1]); + obj_vn[numvn*3+1] = atof(argv[2]); + obj_vn[numvn*3+2] = atof(argv[3]); + } + numvn++; + } + else if (!strcmp(argv[0], "f")) + { + if (!numtextures) + { + if (maxtextures <= numtextures) + { + maxtextures = max(maxtextures * 2, 256); + texturenames = (char *)Mem_Realloc(loadmodel->mempool, texturenames, maxtextures * MAX_QPATH); + } + textureindex = numtextures++; + strlcpy(texturenames + textureindex*MAX_QPATH, loadmodel->name, MAX_QPATH); + } + 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; + vcurrent.nextindex = -1; + vcurrent.textureindex = textureindex; + vcurrent.submodelindex = submodelindex; + if (obj_v && index1 >= 0 && index1 < numv) + VectorCopy(obj_v + 3*index1, vcurrent.v); + if (obj_vt && index2 >= 0 && index2 < numvt) + Vector2Copy(obj_vt + 2*index2, vcurrent.vt); + if (obj_vn && index3 >= 0 && index3 < numvn) + VectorCopy(obj_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) + { + maxtriangles = max(maxtriangles * 2, 32768); + vertices = (objvertex_t*)Mem_Realloc(loadmodel->mempool, vertices, maxtriangles * sizeof(objvertex_t[3])); + } + if(mod_obj_orientation.integer) + { + vertices[numtriangles*3+0] = vfirst; + vertices[numtriangles*3+1] = vprev; + vertices[numtriangles*3+2] = vcurrent; + } + else + { + vertices[numtriangles*3+0] = vfirst; + vertices[numtriangles*3+2] = vprev; + vertices[numtriangles*3+1] = vcurrent; + } + numtriangles++; + } + vprev = vcurrent; + } + } + else if (!strcmp(argv[0], "o") || !strcmp(argv[0], "g")) + { + submodelindex = atof(argv[1]); + loadmodel->brush.numsubmodels = max(submodelindex + 1, loadmodel->brush.numsubmodels); + } + else if (!strcmp(argv[0], "usemtl")) + { + for (i = 0;i < numtextures;i++) + if (!strcmp(texturenames+i*MAX_QPATH, argv[1])) + break; + if (i < numtextures) + textureindex = i; + else + { + if (maxtextures <= numtextures) + { + maxtextures = max(maxtextures * 2, 256); + texturenames = (char *)Mem_Realloc(loadmodel->mempool, texturenames, maxtextures * MAX_QPATH); + } + textureindex = numtextures++; + strlcpy(texturenames + textureindex*MAX_QPATH, argv[1], MAX_QPATH); + } + } + } - if(model->brush.TraceLineOfSight(model, eye, testorigin)) - return 1; + // now that we have the OBJ data loaded as-is, we can convert it + + // 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; + + // allocate storage for triangles + loadmodel->surfmesh.data_element3i = (int *)Mem_Alloc(loadmodel->mempool, numtriangles * sizeof(int[3])); + // allocate vertex hash structures to build an optimal vertex subset + vertexhashsize = numtriangles*2; + vertexhashtable = (int *)Mem_Alloc(loadmodel->mempool, sizeof(int) * vertexhashsize); + memset(vertexhashtable, 0xFF, sizeof(int) * vertexhashsize); + vertexhashdata = (objvertex_t *)Mem_Alloc(loadmodel->mempool, sizeof(*vertexhashdata) * numtriangles*3); + vertexhashcount = 0; + + // gather surface stats for assigning vertex/triangle ranges + firstvertex = 0; + firsttriangle = 0; + elementindex = 0; + loadmodel->num_surfaces = 0; + // allocate storage for the worst case number of surfaces, later we resize + tempsurfaces = (msurface_t *)Mem_Alloc(loadmodel->mempool, numtextures * loadmodel->brush.numsubmodels * sizeof(msurface_t)); + submodelfirstsurface = (int *)Mem_Alloc(loadmodel->mempool, (loadmodel->brush.numsubmodels+1) * sizeof(int)); + tempsurface = tempsurfaces; + for (submodelindex = 0;submodelindex < loadmodel->brush.numsubmodels;submodelindex++) + { + submodelfirstsurface[submodelindex] = loadmodel->num_surfaces; + for (textureindex = 0;textureindex < numtextures;textureindex++) + { + for (vertexindex = 0;vertexindex < numtriangles*3;vertexindex++) + { + thisvertex = vertices + vertexindex; + if (thisvertex->submodelindex == submodelindex && thisvertex->textureindex == textureindex) + break; + } + // skip the surface creation if there are no triangles for it + if (vertexindex == numtriangles*3) + continue; + // create a surface for these vertices + surfacevertices = 0; + surfaceelements = 0; + // we hack in a texture index in the surface to be fixed up later... + tempsurface->texture = (texture_t *)((size_t)textureindex); + // calculate bounds as we go + VectorCopy(thisvertex->v, tempsurface->mins); + VectorCopy(thisvertex->v, tempsurface->maxs); + for (;vertexindex < numtriangles*3;vertexindex++) + { + thisvertex = vertices + vertexindex; + if (thisvertex->submodelindex != submodelindex) + continue; + if (thisvertex->textureindex != textureindex) + continue; + // add vertex to surface bounds + tempsurface->mins[0] = min(tempsurface->mins[0], thisvertex->v[0]); + tempsurface->mins[1] = min(tempsurface->mins[1], thisvertex->v[1]); + tempsurface->mins[2] = min(tempsurface->mins[2], thisvertex->v[2]); + tempsurface->maxs[0] = max(tempsurface->maxs[0], thisvertex->v[0]); + tempsurface->maxs[1] = max(tempsurface->maxs[1], thisvertex->v[1]); + tempsurface->maxs[2] = max(tempsurface->maxs[2], thisvertex->v[2]); + // add the vertex if it is not found in the merged set, and + // get its index (triangle element) for the surface + vertexhashindex = (unsigned int)(thisvertex->v[0] * 3571 + thisvertex->v[0] * 1777 + thisvertex->v[0] * 457) % (unsigned int)vertexhashsize; + for (i = vertexhashtable[vertexhashindex];i >= 0;i = vertexhashdata[i].nextindex) + { + vdata = vertexhashdata + i; + if (vdata->submodelindex == thisvertex->submodelindex && vdata->textureindex == thisvertex->textureindex && VectorCompare(thisvertex->v, vdata->v) && VectorCompare(thisvertex->vn, vdata->vn) && Vector2Compare(thisvertex->vt, vdata->vt)) + break; + } + if (i < 0) + { + i = vertexhashcount++; + vdata = vertexhashdata + i; + *vdata = *thisvertex; + vdata->nextindex = vertexhashtable[vertexhashindex]; + vertexhashtable[vertexhashindex] = i; + surfacevertices++; + } + loadmodel->surfmesh.data_element3i[elementindex++] = i; + surfaceelements++; + } + surfacetriangles = surfaceelements / 3; + tempsurface->num_vertices = surfacevertices; + tempsurface->num_triangles = surfacetriangles; + tempsurface->num_firstvertex = firstvertex; + tempsurface->num_firsttriangle = firsttriangle; + firstvertex += tempsurface->num_vertices; + firsttriangle += tempsurface->num_triangles; + tempsurface++; + loadmodel->num_surfaces++; + } + } + submodelfirstsurface[submodelindex] = loadmodel->num_surfaces; + numvertices = firstvertex; + loadmodel->data_surfaces = (msurface_t *)Mem_Realloc(loadmodel->mempool, tempsurfaces, loadmodel->num_surfaces * sizeof(msurface_t)); + tempsurfaces = NULL; + + // allocate storage for final mesh data + loadmodel->num_textures = numtextures * loadmodel->numskins; + loadmodel->num_texturesperskin = numtextures; + data = (unsigned char *)Mem_Alloc(loadmodel->mempool, loadmodel->num_surfaces * sizeof(int) + loadmodel->num_surfaces * loadmodel->numskins * sizeof(texture_t) + numtriangles * sizeof(int[3]) + (numvertices <= 65536 ? numtriangles * sizeof(unsigned short[3]) : 0) + numvertices * sizeof(float[14]) + loadmodel->brush.numsubmodels * sizeof(dp_model_t *)); + loadmodel->brush.submodels = (dp_model_t **)data;data += loadmodel->brush.numsubmodels * sizeof(dp_model_t *); + loadmodel->sortedmodelsurfaces = (int *)data;data += loadmodel->num_surfaces * sizeof(int); + loadmodel->data_textures = (texture_t *)data;data += loadmodel->num_surfaces * loadmodel->numskins * sizeof(texture_t); + loadmodel->surfmesh.num_vertices = numvertices; + loadmodel->surfmesh.num_triangles = numtriangles; + loadmodel->surfmesh.data_vertex3f = (float *)data;data += numvertices * sizeof(float[3]); + loadmodel->surfmesh.data_svector3f = (float *)data;data += numvertices * sizeof(float[3]); + loadmodel->surfmesh.data_tvector3f = (float *)data;data += numvertices * sizeof(float[3]); + loadmodel->surfmesh.data_normal3f = (float *)data;data += numvertices * sizeof(float[3]); + loadmodel->surfmesh.data_texcoordtexture2f = (float *)data;data += numvertices * sizeof(float[2]); + if (loadmodel->surfmesh.num_vertices <= 65536) + loadmodel->surfmesh.data_element3s = (unsigned short *)data;data += loadmodel->surfmesh.num_triangles * sizeof(unsigned short[3]); + + for (j = 0;j < loadmodel->surfmesh.num_vertices;j++) + { + VectorCopy(vertexhashdata[j].v, loadmodel->surfmesh.data_vertex3f + 3*j); + VectorCopy(vertexhashdata[j].vn, loadmodel->surfmesh.data_normal3f + 3*j); + Vector2Copy(vertexhashdata[j].vt, loadmodel->surfmesh.data_texcoordtexture2f + 2*j); + } + + // load the textures + for (textureindex = 0;textureindex < numtextures;textureindex++) + Mod_BuildAliasSkinsFromSkinFiles(loadmodel->data_textures + textureindex, skinfiles, texturenames + textureindex*MAX_QPATH, texturenames + textureindex*MAX_QPATH); + Mod_FreeSkinFiles(skinfiles); + + // set the surface textures to their real values now that we loaded them... + for (i = 0;i < loadmodel->num_surfaces;i++) + loadmodel->data_surfaces[i].texture = loadmodel->data_textures + (size_t)loadmodel->data_surfaces[i].texture; + + // free data + Mem_Free(vertices); + Mem_Free(texturenames); + Mem_Free(obj_v); + Mem_Free(obj_vt); + Mem_Free(obj_vn); + Mem_Free(vertexhashtable); + Mem_Free(vertexhashdata); + + // compute all the mesh information that was not loaded from the file + 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]; + Mod_ValidateElements(loadmodel->surfmesh.data_element3i, loadmodel->surfmesh.data_element3s, loadmodel->surfmesh.num_triangles, 0, loadmodel->surfmesh.num_vertices, __FILE__, __LINE__); + // generate normals if the file did not have them + if (!VectorLength2(loadmodel->surfmesh.data_normal3f)) + Mod_BuildNormals(0, loadmodel->surfmesh.num_vertices, loadmodel->surfmesh.num_triangles, loadmodel->surfmesh.data_vertex3f, loadmodel->surfmesh.data_element3i, loadmodel->surfmesh.data_normal3f, r_smoothnormals_areaweighting.integer != 0); + 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, r_smoothnormals_areaweighting.integer != 0); + + // if this is a worldmodel and has no BSP tree, create a fake one for the purpose + loadmodel->brush.num_visleafs = 1; + loadmodel->brush.num_leafs = 1; + loadmodel->brush.num_nodes = 0; + loadmodel->brush.num_leafsurfaces = loadmodel->num_surfaces; + loadmodel->brush.data_leafs = (mleaf_t *)Mem_Alloc(loadmodel->mempool, loadmodel->brush.num_leafs * sizeof(mleaf_t)); + loadmodel->brush.data_nodes = (mnode_t *)loadmodel->brush.data_leafs; + loadmodel->brush.num_pvsclusters = 1; + loadmodel->brush.num_pvsclusterbytes = 1; + loadmodel->brush.data_pvsclusters = nobsp_pvs; + //if (loadmodel->num_nodes) loadmodel->data_nodes = (mnode_t *)Mem_Alloc(loadmodel->mempool, loadmodel->num_nodes * sizeof(mnode_t)); + //loadmodel->data_leafsurfaces = (int *)Mem_Alloc(loadmodel->mempool, loadmodel->num_leafsurfaces * sizeof(int)); + loadmodel->brush.data_leafsurfaces = loadmodel->sortedmodelsurfaces; + VectorCopy(loadmodel->normalmins, loadmodel->brush.data_leafs->mins); + VectorCopy(loadmodel->normalmaxs, loadmodel->brush.data_leafs->maxs); + loadmodel->brush.data_leafs->combinedsupercontents = 0; // FIXME? + loadmodel->brush.data_leafs->clusterindex = 0; + loadmodel->brush.data_leafs->areaindex = 0; + loadmodel->brush.data_leafs->numleafsurfaces = loadmodel->brush.num_leafsurfaces; + loadmodel->brush.data_leafs->firstleafsurface = loadmodel->brush.data_leafsurfaces; + loadmodel->brush.data_leafs->numleafbrushes = 0; + loadmodel->brush.data_leafs->firstleafbrush = NULL; + loadmodel->brush.supportwateralpha = true; - // expand the box a little - mins[0] = (t+1) * minsX[0] - t * maxsX[0]; - maxs[0] = (t+1) * maxsX[0] - t * minsX[0]; - mins[1] = (t+1) * minsX[1] - t * maxsX[1]; - maxs[1] = (t+1) * maxsX[1] - t * minsX[1]; - mins[2] = (t+1) * minsX[2] - t * maxsX[2]; - maxs[2] = (t+1) * maxsX[2] - t * minsX[2]; + if (loadmodel->brush.numsubmodels) + loadmodel->brush.submodels = (dp_model_t **)Mem_Alloc(loadmodel->mempool, loadmodel->brush.numsubmodels * sizeof(dp_model_t *)); - for(i = 0; i != numsamples; ++i) + mod = loadmodel; + for (i = 0;i < loadmodel->brush.numsubmodels;i++) { - testorigin[0] = lhrandom(mins[0], maxs[0]); - testorigin[1] = lhrandom(mins[1], maxs[1]); - testorigin[2] = lhrandom(mins[2], maxs[2]); + if (i > 0) + { + char name[10]; + // duplicate the basic information + 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; + if (loadmodel->brush.submodels) + loadmodel->brush.submodels[i] = mod; + + // make the model surface list (used by shadowing/lighting) + mod->firstmodelsurface = submodelfirstsurface[i]; + mod->nummodelsurfaces = submodelfirstsurface[i+1] - submodelfirstsurface[i]; + mod->firstmodelbrush = 0; + mod->nummodelbrushes = 0; + mod->sortedmodelsurfaces = loadmodel->sortedmodelsurfaces + mod->firstmodelsurface; + Mod_MakeSortedSurfaces(mod); + + VectorClear(mod->normalmins); + VectorClear(mod->normalmaxs); + l = false; + for (j = 0;j < mod->nummodelsurfaces;j++) + { + const msurface_t *surface = mod->data_surfaces + j + mod->firstmodelsurface; + const float *v3f = mod->surfmesh.data_vertex3f + 3 * surface->num_firstvertex; + int k; + if (!surface->num_vertices) + continue; + if (!l) + { + l = true; + VectorCopy(v3f, mod->normalmins); + VectorCopy(v3f, mod->normalmaxs); + } + for (k = 0;k < surface->num_vertices;k++, v3f += 3) + { + mod->normalmins[0] = min(mod->normalmins[0], v3f[0]); + mod->normalmins[1] = min(mod->normalmins[1], v3f[1]); + mod->normalmins[2] = min(mod->normalmins[2], v3f[2]); + mod->normalmaxs[0] = max(mod->normalmaxs[0], v3f[0]); + mod->normalmaxs[1] = max(mod->normalmaxs[1], v3f[1]); + mod->normalmaxs[2] = max(mod->normalmaxs[2], v3f[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])); + modelradius = sqrt(corner[0]*corner[0]+corner[1]*corner[1]+corner[2]*corner[2]); + yawradius = sqrt(corner[0]*corner[0]+corner[1]*corner[1]); + mod->rotatedmins[0] = mod->rotatedmins[1] = mod->rotatedmins[2] = -modelradius; + mod->rotatedmaxs[0] = mod->rotatedmaxs[1] = mod->rotatedmaxs[2] = modelradius; + mod->yawmaxs[0] = mod->yawmaxs[1] = yawradius; + mod->yawmins[0] = mod->yawmins[1] = -yawradius; + mod->yawmins[2] = mod->normalmins[2]; + mod->yawmaxs[2] = mod->normalmaxs[2]; + 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; + + for (j = 0;j < mod->nummodelsurfaces;j++) + if (mod->data_surfaces[j + mod->firstmodelsurface].texture->basematerialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION | MATERIALFLAG_REFLECTION | MATERIALFLAG_CAMERA)) + break; + if (j < mod->nummodelsurfaces) + mod->DrawAddWaterPlanes = R_Q1BSP_DrawAddWaterPlanes; - if(model->brush.TraceLineOfSight(model, eye, testorigin)) - return 1; + Mod_MakeCollisionBIH(mod, true, &mod->collision_bih); + mod->render_bih = mod->collision_bih; + + // generate VBOs and other shared data before cloning submodels + if (i == 0) + Mod_BuildVBOs(); } + mod = loadmodel; + Mem_Free(submodelfirstsurface); - return 0; + Con_DPrintf("Stats for obj model \"%s\": %i faces, %i nodes, %i leafs, %i clusters, %i clusterportals, mesh: %i vertices, %i triangles, %i surfaces\n", loadmodel->name, loadmodel->num_surfaces, loadmodel->brush.num_nodes, loadmodel->brush.num_leafs, mod->brush.num_pvsclusters, loadmodel->brush.num_portals, loadmodel->surfmesh.num_vertices, loadmodel->surfmesh.num_triangles, loadmodel->num_surfaces); } -