don't load corrupt wav files
[divverent/darkplaces.git] / model_brush.c
index 200fc69..54dafb2 100644 (file)
@@ -28,7 +28,6 @@ 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 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)"};
@@ -39,12 +38,20 @@ cvar_t r_subdivisions_collision_mintess = {0, "r_subdivisions_collision_mintess"
 cvar_t r_subdivisions_collision_maxtess = {0, "r_subdivisions_collision_maxtess", "1024", "maximum number of subdivisions (prevents curves beyond a certain detail level, limits smoothing)"};
 cvar_t r_subdivisions_collision_maxvertices = {0, "r_subdivisions_collision_maxvertices", "4225", "maximum vertices allowed per subdivided curve"};
 cvar_t mod_q3bsp_curves_collisions = {0, "mod_q3bsp_curves_collisions", "1", "enables collisions with curves (SLOW)"};
-cvar_t mod_q3bsp_curves_collisions_stride = {0, "mod_q3bsp_curves_collisions_stride", "16", "collisions against curves: optimize performance by doing a combined collision check for this triangle amount first"};
-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_q3shader_default_offsetmapping = {CVAR_SAVE, "mod_q3shader_default_offsetmapping", "1", "use offsetmapping by default on all surfaces"};
+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_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;
@@ -56,7 +63,6 @@ void Mod_BrushInit(void)
 {
 //     Cvar_RegisterVariable(&r_subdivide_size);
        Cvar_RegisterVariable(&r_novis);
-       Cvar_RegisterVariable(&r_picmipworld);
        Cvar_RegisterVariable(&r_nosurftextures);
        Cvar_RegisterVariable(&r_subdivisions_tolerance);
        Cvar_RegisterVariable(&r_subdivisions_mintess);
@@ -73,6 +79,13 @@ void Mod_BrushInit(void)
        Cvar_RegisterVariable(&mod_q3bsp_debugtracebrush);
        Cvar_RegisterVariable(&mod_q3bsp_lightmapmergepower);
        Cvar_RegisterVariable(&mod_q3bsp_nolightmaps);
+       Cvar_RegisterVariable(&mod_q3bsp_tracelineofsight_brushes);
+       Cvar_RegisterVariable(&mod_q3shader_default_offsetmapping);
+       Cvar_RegisterVariable(&mod_q3shader_default_polygonfactor);
+       Cvar_RegisterVariable(&mod_q3shader_default_polygonoffset);
+       Cvar_RegisterVariable(&mod_q1bsp_polygoncollisions);
+       Cvar_RegisterVariable(&mod_collision_bih);
+       Cvar_RegisterVariable(&mod_recalculatenodeboxes);
 
        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 +155,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 +220,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 +291,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 +362,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 +533,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);
@@ -851,12 +864,89 @@ static int Mod_Q1BSP_RecursiveHullCheckPoint(RecursiveHullCheckTraceInfo_t *t, i
 }
 //#endif
 
-static void Mod_Q1BSP_TraceBox(struct model_s *model, int frame, trace_t *trace, const vec3_t start, const vec3_t boxmins, const vec3_t boxmaxs, const vec3_t end, int hitsupercontentsmask)
+static void Mod_Q1BSP_TracePoint(struct model_s *model, const frameblend_t *frameblend, const skeleton_t *skeleton, trace_t *trace, const vec3_t start, int hitsupercontentsmask)
+{
+       RecursiveHullCheckTraceInfo_t rhc;
+
+       memset(&rhc, 0, sizeof(rhc));
+       memset(trace, 0, sizeof(trace_t));
+       rhc.trace = trace;
+       rhc.trace->fraction = 1;
+       rhc.trace->realfraction = 1;
+       rhc.trace->allsolid = true;
+       rhc.hull = &model->brushq1.hulls[0]; // 0x0x0
+       VectorCopy(start, rhc.start);
+       VectorCopy(start, rhc.end);
+       Mod_Q1BSP_RecursiveHullCheckPoint(&rhc, rhc.hull->firstclipnode);
+}
+
+static void Mod_Q1BSP_TraceLine(struct model_s *model, const frameblend_t *frameblend, const skeleton_t *skeleton, trace_t *trace, const vec3_t start, const vec3_t end, int hitsupercontentsmask)
+{
+       RecursiveHullCheckTraceInfo_t rhc;
+
+       if (VectorCompare(start, end))
+       {
+               Mod_Q1BSP_TracePoint(model, frameblend, skeleton, trace, start, hitsupercontentsmask);
+               return;
+       }
+
+       memset(&rhc, 0, sizeof(rhc));
+       memset(trace, 0, sizeof(trace_t));
+       rhc.trace = trace;
+       rhc.trace->hitsupercontentsmask = hitsupercontentsmask;
+       rhc.trace->fraction = 1;
+       rhc.trace->realfraction = 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);
+#if COLLISIONPARANOID >= 2
+       Con_Printf("t(%f %f %f,%f %f %f)", rhc.start[0], rhc.start[1], rhc.start[2], rhc.end[0], rhc.end[1], rhc.end[2]);
+       Mod_Q1BSP_RecursiveHullCheck(&rhc, rhc.hull->firstclipnode, 0, 1, rhc.start, rhc.end);
+       {
+
+               double test[3];
+               trace_t testtrace;
+               VectorLerp(rhc.start, rhc.trace->fraction, rhc.end, test);
+               memset(&testtrace, 0, sizeof(trace_t));
+               rhc.trace = &testtrace;
+               rhc.trace->hitsupercontentsmask = hitsupercontentsmask;
+               rhc.trace->fraction = 1;
+               rhc.trace->realfraction = 1;
+               rhc.trace->allsolid = true;
+               VectorCopy(test, rhc.start);
+               VectorCopy(test, rhc.end);
+               VectorClear(rhc.dist);
+               Mod_Q1BSP_RecursiveHullCheckPoint(&rhc, rhc.hull->firstclipnode);
+               //Mod_Q1BSP_RecursiveHullCheck(&rhc, rhc.hull->firstclipnode, 0, 1, test, test);
+               if (!trace->startsolid && testtrace.startsolid)
+                       Con_Printf(" - ended in solid!\n");
+       }
+       Con_Print("\n");
+#else
+       if (VectorLength2(rhc.dist))
+               Mod_Q1BSP_RecursiveHullCheck(&rhc, rhc.hull->firstclipnode, 0, 1, rhc.start, rhc.end);
+       else
+               Mod_Q1BSP_RecursiveHullCheckPoint(&rhc, rhc.hull->firstclipnode);
+#endif
+}
+
+static void Mod_Q1BSP_TraceBox(struct model_s *model, const frameblend_t *frameblend, const skeleton_t *skeleton, trace_t *trace, const vec3_t start, const vec3_t boxmins, const vec3_t boxmaxs, const vec3_t end, int hitsupercontentsmask)
 {
        // this function currently only supports same size start and end
        double boxsize[3];
        RecursiveHullCheckTraceInfo_t rhc;
 
+       if (VectorCompare(boxmins, boxmaxs))
+       {
+               if (VectorCompare(start, end))
+                       Mod_Q1BSP_TracePoint(model, frameblend, skeleton, trace, start, hitsupercontentsmask);
+               else
+                       Mod_Q1BSP_TraceLine(model, frameblend, skeleton, trace, start, end, hitsupercontentsmask);
+               return;
+       }
+
        memset(&rhc, 0, sizeof(rhc));
        memset(trace, 0, sizeof(trace_t));
        rhc.trace = trace;
@@ -938,11 +1028,13 @@ static int Mod_Q1BSP_PointSuperContents(struct model_s *model, int frame, const
        return Mod_Q1BSP_SuperContentsFromNativeContents(NULL, num);
 }
 
-void Collision_ClipTrace_Box(trace_t *trace, const vec3_t cmins, const vec3_t cmaxs, const vec3_t start, const vec3_t mins, const vec3_t maxs, const vec3_t end, int hitsupercontentsmask, int boxsupercontents, int boxq3surfaceflags, texture_t *boxtexture)
+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, 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;
@@ -1042,74 +1134,27 @@ void Collision_ClipTrace_Box(trace_t *trace, const vec3_t cmins, const vec3_t cm
 #endif
 }
 
-static int Mod_Q1BSP_TraceLineOfSight_RecursiveNodeCheck(mnode_t *node, double p1[3], double p2[3])
+void Collision_ClipTrace_Point(trace_t *trace, const vec3_t cmins, const vec3_t cmaxs, const vec3_t start, int hitsupercontentsmask, int boxsupercontents, int boxq3surfaceflags, const texture_t *boxtexture)
 {
-       double t1, t2;
-       double midf, mid[3];
-       int ret, side;
-
-       // check for empty
-       while (node->plane)
+       memset(trace, 0, sizeof(trace_t));
+       trace->fraction = 1;
+       trace->realfraction = 1;
+       if (BoxesOverlap(start, start, cmins, cmaxs))
        {
-               // find the point distances
-               mplane_t *plane = node->plane;
-               if (plane->type < 3)
-               {
-                       t1 = p1[plane->type] - plane->dist;
-                       t2 = p2[plane->type] - plane->dist;
-               }
-               else
-               {
-                       t1 = DotProduct (plane->normal, p1) - plane->dist;
-                       t2 = DotProduct (plane->normal, p2) - plane->dist;
-               }
-
-               if (t1 < 0)
-               {
-                       if (t2 < 0)
-                       {
-                               node = node->children[1];
-                               continue;
-                       }
-                       side = 1;
-               }
-               else
+               trace->startsupercontents |= boxsupercontents;
+               if (hitsupercontentsmask & boxsupercontents)
                {
-                       if (t2 >= 0)
-                       {
-                               node = node->children[0];
-                               continue;
-                       }
-                       side = 0;
+                       trace->startsolid = true;
+                       trace->allsolid = true;
                }
-
-               midf = t1 / (t1 - t2);
-               VectorLerp(p1, midf, p2, mid);
-
-               // recurse both sides, front side first
-               // return 2 if empty is followed by solid (hit something)
-               // do not return 2 if both are solid or both empty,
-               // or if start is solid and end is empty
-               // as these degenerate cases usually indicate the eye is in solid and
-               // should see the target point anyway
-               ret = Mod_Q1BSP_TraceLineOfSight_RecursiveNodeCheck(node->children[side    ], p1, mid);
-               if (ret != 0)
-                       return ret;
-               ret = Mod_Q1BSP_TraceLineOfSight_RecursiveNodeCheck(node->children[side ^ 1], mid, p2);
-               if (ret != 1)
-                       return ret;
-               return 2;
        }
-       return ((mleaf_t *)node)->clusterindex < 0;
 }
 
 static qboolean Mod_Q1BSP_TraceLineOfSight(struct model_s *model, const vec3_t start, const vec3_t end)
 {
-       // this function currently only supports same size start and end
-       double tracestart[3], traceend[3];
-       VectorCopy(start, tracestart);
-       VectorCopy(end, traceend);
-       return Mod_Q1BSP_TraceLineOfSight_RecursiveNodeCheck(model->brush.data_nodes, tracestart, traceend) != 2;
+       trace_t trace;
+       model->TraceLine(model, NULL, NULL, &trace, start, end, SUPERCONTENTS_VISBLOCKERMASK);
+       return trace.fraction == 1;
 }
 
 static int Mod_Q1BSP_LightPoint_RecursiveBSPNode(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)
@@ -1175,7 +1220,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
@@ -1289,8 +1334,11 @@ A sky texture is 256*128, with the right side being a masked overlay
 */
 void R_Q1BSP_LoadSplitSky (unsigned char *src, int width, int height, int bytesperpixel)
 {
-       int i, j;
-       unsigned solidpixels[128*128], alphapixels[128*128];
+       int x, y;
+       int w = width/2;
+       int h = height;
+       unsigned 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)
@@ -1298,12 +1346,12 @@ void R_Q1BSP_LoadSplitSky (unsigned char *src, int width, int height, int bytesp
 
        if (bytesperpixel == 4)
        {
-               for (i = 0;i < 128;i++)
+               for (y = 0;y < h;y++)
                {
-                       for (j = 0;j < 128;j++)
+                       for (x = 0;x < w;x++)
                        {
-                               solidpixels[(i*128) + j] = ((unsigned *)src)[i*256+j+128];
-                               alphapixels[(i*128) + j] = ((unsigned *)src)[i*256+j];
+                               solidpixels[y*w+x] = ((unsigned *)src)[y*width+x+w];
+                               alphapixels[y*w+x] = ((unsigned *)src)[y*width+x];
                        }
                }
        }
@@ -1319,33 +1367,35 @@ void R_Q1BSP_LoadSplitSky (unsigned char *src, int width, int height, int bytesp
                }
                bgra;
                r = g = b = 0;
-               for (i = 0;i < 128;i++)
+               for (y = 0;y < h;y++)
                {
-                       for (j = 0;j < 128;j++)
+                       for (x = 0;x < w;x++)
                        {
-                               p = src[i*256 + j + 128];
+                               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/(128*128);
-               bgra.b[1] = g/(128*128);
-               bgra.b[0] = b/(128*128);
+               bgra.b[2] = r/(w*h);
+               bgra.b[1] = g/(w*h);
+               bgra.b[0] = b/(w*h);
                bgra.b[3] = 0;
-               for (i = 0;i < 128;i++)
+               for (y = 0;y < h;y++)
                {
-                       for (j = 0;j < 128;j++)
+                       for (x = 0;x < w;x++)
                        {
-                               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;
+                               solidpixels[y*w+x] = palette_bgra_complete[src[y*width+x+w]];
+                               p = src[y*width+x];
+                               alphapixels[y*w+x] = p ? palette_bgra_complete[p] : bgra.i;
                        }
                }
        }
 
-       loadmodel->brush.solidskytexture = R_LoadTexture2D(loadmodel->texturepool, "sky_solidtexture", 128, 128, (unsigned char *) solidpixels, TEXTYPE_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);
+       loadmodel->brush.solidskyskinframe = R_SkinFrame_LoadInternalBGRA("sky_solidtexture", 0         , (unsigned char *) solidpixels, w, h);
+       loadmodel->brush.alphaskyskinframe = R_SkinFrame_LoadInternalBGRA("sky_alphatexture", TEXF_ALPHA, (unsigned char *) alphapixels, w, h);
+       Mem_Free(solidpixels);
+       Mem_Free(alphapixels);
 }
 
 static void Mod_Q1BSP_LoadTextures(lump_t *l)
@@ -1420,6 +1470,10 @@ 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_OFF;
+               tx->offsetscale = 1;
+               tx->specularscalemod = 1;
+               tx->specularpowermod = 1;
        }
 
        if (!m)
@@ -1524,10 +1578,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("textures/%s/%s", mapname, tx->name), false, false, r_texture_convertsRGB_skin.integer != 0, NULL);
+                               if (!data)
+                                       data = loadimagepixelsbgra(gamemode == GAME_TENEBRAE ? tx->name : va("textures/%s", tx->name), false, false, r_texture_convertsRGB_skin.integer != 0, NULL);
+                               if (data && image_width == image_height * 2)
                                {
                                        R_Q1BSP_LoadSplitSky(data, image_width, image_height, 4);
                                        Mem_Free(data);
@@ -1537,9 +1593,9 @@ 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 = R_SkinFrame_LoadExternal(gamemode == GAME_TENEBRAE ? tx->name : va("textures/%s/%s", mapname, tx->name), TEXF_ALPHA | TEXF_MIPMAP | TEXF_ISWORLD | TEXF_PICMIP | TEXF_COMPRESS, 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("textures/%s", tx->name), TEXF_ALPHA | TEXF_MIPMAP | TEXF_ISWORLD | TEXF_PICMIP | TEXF_COMPRESS, false);
                                if (!skinframe)
                                {
                                        // did not find external texture, load it from the bsp or wad3
@@ -1556,13 +1612,13 @@ static void Mod_Q1BSP_LoadTextures(lump_t *l)
                                                {
                                                        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);
                                                }
                                                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)
@@ -1577,7 +1633,7 @@ static void Mod_Q1BSP_LoadTextures(lump_t *l)
                                {
                                        // 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->skinframes[0] = R_SkinFrame_LoadInternalBGRA(tx->name, TEXF_MIPMAP | TEXF_ALPHA, zero, 1, 1);
                                        tx->basematerialflags |= MATERIALFLAG_NOSHADOW | MATERIALFLAG_ADD | MATERIALFLAG_BLENDED | MATERIALFLAG_REFLECTION;
                                }
                                else if (!strncmp(tx->name,"*lava",5)
@@ -1586,20 +1642,20 @@ static void Mod_Q1BSP_LoadTextures(lump_t *l)
                                        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)
+                               if (tx->skinframes[0] && tx->skinframes[0]->hasalpha)
                                        tx->basematerialflags |= MATERIALFLAG_ALPHA | MATERIALFLAG_BLENDED | MATERIALFLAG_NOSHADOW;
                        }
                        else if (!strncmp(tx->name, "mirror", 6)) // Tenebrae
                        {
                                // replace the texture with black
-                               tx->skinframes[0] = R_SkinFrame_LoadInternalBGRA(tx->name, TEXF_PRECACHE, zero, 1, 1);
+                               tx->skinframes[0] = R_SkinFrame_LoadInternalBGRA(tx->name, 0, 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)
+                       else if (tx->skinframes[0] && tx->skinframes[0]->hasalpha)
                                tx->basematerialflags |= MATERIALFLAG_ALPHA | MATERIALFLAG_BLENDED | MATERIALFLAG_NOSHADOW;
 
                        // start out with no animation
@@ -2189,71 +2245,7 @@ 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;
+extern cvar_t gl_max_lightmapsize;
 static void Mod_Q1BSP_LoadFaces(lump_t *l)
 {
        dface_t *in;
@@ -2271,6 +2263,7 @@ static void Mod_Q1BSP_LoadFaces(lump_t *l)
 
        loadmodel->num_surfaces = count;
 
+       loadmodel->brushq1.firstrender = true;
        loadmodel->brushq1.lightmapupdateflags = (unsigned char *)Mem_Alloc(loadmodel->mempool, count*sizeof(unsigned char));
 
        totalverts = 0;
@@ -2286,8 +2279,8 @@ static void Mod_Q1BSP_LoadFaces(lump_t *l)
 
        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;
@@ -2386,7 +2379,7 @@ static void Mod_Q1BSP_LoadFaces(lump_t *l)
                if (i == -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)
                        {
@@ -2424,26 +2417,27 @@ 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, lightmapsize, lightmapsize);
                for (surfacenum = 0, surface = loadmodel->data_surfaces;surfacenum < count;surfacenum++, surface++)
                {
                        int i, iu, iv, lightmapx = 0, lightmapy = 0;
@@ -2458,18 +2452,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("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("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;
@@ -2949,26 +2946,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)
 {
@@ -2991,8 +2969,8 @@ static void Mod_Q1BSP_RecursiveRecalcNodeBBox(mnode_t *node)
 
 static void Mod_Q1BSP_FinalizePortals(void)
 {
-       int i, j, numportals, numpoints;
-       portal_t *p, *pnext;
+       int i, j, numportals, numpoints, portalindex, portalrange = Mem_ExpandableArray_IndexRange(&portalarray);
+       portal_t *p;
        mportal_t *portal;
        mvertex_t *point;
        mleaf_t *leaf, *endleaf;
@@ -3001,16 +2979,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)
@@ -3018,7 +3001,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;
@@ -3030,12 +3012,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
@@ -3089,25 +3070,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);
 }
 
 /*
@@ -3184,6 +3167,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;
@@ -3191,12 +3177,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];
@@ -3206,7 +3203,7 @@ static void Mod_Q1BSP_RecursiveNodePortals(mnode_t *node)
 
        // create the new portal by generating a polygon for the node plane,
        // and clipping it by all of the other portals(which came from nodes above this one)
-       nodeportal = AllocPortal();
+       nodeportal = (portal_t *)Mem_ExpandableArray_AllocRecord(&portalarray);
        nodeportal->plane = *plane;
 
        // TODO: calculate node bounding boxes during recursion and calculate a maximum plane size accordingly to improve precision (as most maps do not need 1 billion unit plane polygons)
@@ -3289,7 +3286,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;
@@ -3314,13 +3311,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
@@ -3328,7 +3335,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)
@@ -3376,7 +3383,7 @@ static int Mod_Q1BSP_FatPVS(dp_model_t *model, const vec3_t org, vec_t radius, u
        }
        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;
 }
 
@@ -3413,15 +3420,38 @@ static void Mod_Q1BSP_RoundUpToHullSize(dp_model_t *cmodel, const vec3_t inmins,
        VectorAdd(inmins, hull->clip_size, outmaxs);
 }
 
+static int Mod_Q1BSP_CreateShadowMesh(dp_model_t *mod)
+{
+       int j;
+       int numshadowmeshtriangles = 0;
+       msurface_t *surface;
+       if (cls.state == ca_dedicated)
+               return 0;
+       // make a single combined shadow mesh to allow optimized shadow volume creation
+
+       for (j = 0, surface = mod->data_surfaces;j < mod->num_surfaces;j++, surface++)
+       {
+               surface->num_firstshadowmeshtriangle = numshadowmeshtriangles;
+               numshadowmeshtriangles += surface->num_triangles;
+       }
+       mod->brush.shadowmesh = Mod_ShadowMesh_Begin(mod->mempool, numshadowmeshtriangles * 3, numshadowmeshtriangles, NULL, NULL, NULL, false, false, true);
+       for (j = 0, surface = mod->data_surfaces;j < mod->num_surfaces;j++, surface++)
+               if (surface->num_triangles > 0)
+                       Mod_ShadowMesh_AddMesh(mod->mempool, mod->brush.shadowmesh, NULL, NULL, NULL, mod->surfmesh.data_vertex3f, NULL, NULL, NULL, NULL, surface->num_triangles, (mod->surfmesh.data_element3i + 3 * surface->num_firsttriangle));
+       mod->brush.shadowmesh = Mod_ShadowMesh_Finish(mod->mempool, mod->brush.shadowmesh, false, true, false);
+       if (mod->brush.shadowmesh)
+               Mod_BuildTriangleNeighbors(mod->brush.shadowmesh->neighbor3i, mod->brush.shadowmesh->element3i, mod->brush.shadowmesh->numtriangles);
+
+       return numshadowmeshtriangles;
+}
+
 void Mod_Q1BSP_Load(dp_model_t *mod, void *buffer, void *bufferend)
 {
        int i, j, k;
        dheader_t *header;
        dmodel_t *bm;
-       mempool_t *mainmempool;
        float dist, modelyawradius, modelradius;
        msurface_t *surface;
-       int numshadowmeshtriangles;
        hullinfo_t hullinfo;
        int totalstylesurfaces, totalstyles, stylecounts[256], remapstyles[256];
        model_brush_lightstyleinfo_t styleinfo[256];
@@ -3472,6 +3502,8 @@ void Mod_Q1BSP_Load(dp_model_t *mod, void *buffer, void *bufferend)
 
        mod->soundfromcenter = true;
        mod->TraceBox = Mod_Q1BSP_TraceBox;
+       mod->TraceLine = Mod_Q1BSP_TraceLine;
+       mod->TracePoint = Mod_Q1BSP_TracePoint;
        mod->PointSuperContents = Mod_Q1BSP_PointSuperContents;
        mod->brush.TraceLineOfSight = Mod_Q1BSP_TraceLineOfSight;
        mod->brush.SuperContentsFromNativeContents = Mod_Q1BSP_SuperContentsFromNativeContents;
@@ -3490,7 +3522,9 @@ 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;
@@ -3502,12 +3536,15 @@ 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(mod_base + header->lumps[i].fileofs, header->lumps[i].filelen);
+               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));
+               temp = Com_BlockChecksum(mod_base + header->lumps[i].fileofs, header->lumps[i].filelen);
+               mod->brush.qw_md4sum2 ^= LittleLong(temp);
        }
 
        Mod_Q1BSP_LoadEntities(&header->lumps[LUMP_ENTITIES]);
@@ -3541,20 +3578,8 @@ void Mod_Q1BSP_Load(dp_model_t *mod, void *buffer, void *bufferend)
        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);
+       Mod_Q1BSP_CreateShadowMesh(loadmodel);
 
        if (loadmodel->brush.numsubmodels)
                loadmodel->brush.submodels = (dp_model_t **)Mem_Alloc(loadmodel->mempool, loadmodel->brush.numsubmodels * sizeof(dp_model_t *));
@@ -3611,7 +3636,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;
@@ -3639,6 +3663,9 @@ 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);
+
                // make the model surface list (used by shadowing/lighting)
                mod->sortedmodelsurfaces = (int *)datapointer;datapointer += mod->nummodelsurfaces * sizeof(int);
                Mod_MakeSortedSurfaces(mod);
@@ -3678,7 +3705,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;
@@ -3727,14 +3754,28 @@ 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();
+               if (mod_q1bsp_polygoncollisions.integer)
+               {
+                       Mod_MakeCollisionBIH(mod, true, &mod->collision_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;
+               }
+               else
+                       Mod_MakeCollisionBIH(mod, true, &mod->render_bih);
 
-       //Mod_Q1BSP_ProcessLightList();
+               // generate VBOs and other shared data before cloning submodels
+               if (i == 0)
+               {
+                       Mod_BuildVBOs();
+                       Mod_Q1BSP_LoadMapBrushes();
+                       //Mod_Q1BSP_ProcessLightList();
+               }
+       }
 
-       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);
+       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_LoadEntities(lump_t *l)
@@ -4189,6 +4230,8 @@ 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
+       // VorteX: q3map2 FS-R generates tangentspace deluxemaps for q3bsp and sets 'deluxeMaps' key
+       loadmodel->brushq3.deluxemapping = false;
        if (data && COM_ParseToken_Simple(&data, false, false) && com_token[0] == '{')
        {
                while (1)
@@ -4206,13 +4249,34 @@ static void Mod_Q3BSP_LoadEntities(lump_t *l)
                        if (!COM_ParseToken_Simple(&data, false, false))
                                break; // error
                        strlcpy(value, com_token, sizeof(value));
-                       if (!strcmp("gridsize", key))
+                       if (!strcasecmp("gridsize", key)) // this one is case insensitive to 100% match q3map2
                        {
 #if _MSC_VER >= 1400
 #define sscanf sscanf_s
 #endif
+#if 0
                                if (sscanf(value, "%f %f %f", &v[0], &v[1], &v[2]) == 3 && v[0] != 0 && v[1] != 0 && v[2] != 0)
                                        VectorCopy(v, loadmodel->brushq3.num_lightgrid_cellsize);
+#else
+                               VectorSet(v, 64, 64, 128);
+                               if(sscanf(value, "%f %f %f", &v[0], &v[1], &v[2]) != 3)
+                                       Con_Printf("Mod_Q3BSP_LoadEntities: funny gridsize \"%s\" in %s, interpreting as \"%f %f %f\" to match q3map2's parsing\n", value, loadmodel->name, v[0], v[1], v[2]);
+                               if (v[0] != 0 && v[1] != 0 && v[2] != 0)
+                                       VectorCopy(v, loadmodel->brushq3.num_lightgrid_cellsize);
+#endif
+                       }
+                       else if (!strcmp("deluxeMaps", key))
+                       {
+                               if (!strcmp(com_token, "1"))
+                               {
+                                       loadmodel->brushq3.deluxemapping = true;
+                                       loadmodel->brushq3.deluxemapping_modelspace = true;
+                               }
+                               else if (!strcmp(com_token, "2"))
+                               {
+                                       loadmodel->brushq3.deluxemapping = true;
+                                       loadmodel->brushq3.deluxemapping_modelspace = false;
+                               }
                        }
                }
        }
@@ -4239,13 +4303,11 @@ static void Mod_Q3BSP_LoadTextures(lump_t *l)
                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));
+               Mod_LoadTextureFromQ3Shader(out + i, out[i].name, true, true, TEXF_MIPMAP | TEXF_ISWORLD | TEXF_PICMIP | TEXF_COMPRESS);
+               // restore the surfaceflags and supercontents
+               out[i].surfaceflags = LittleLong(in[i].surfaceflags);
+               out[i].supercontents = Mod_Q3BSP_SuperContentsFromNativeContents(loadmodel, 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)
@@ -4333,7 +4395,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);
@@ -4369,15 +4431,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);
@@ -4447,6 +4511,8 @@ static void Mod_Q3BSP_LoadVertices(lump_t *l)
                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;
        }
 }
 
@@ -4460,8 +4526,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;
 
@@ -4471,8 +4545,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;
                }
        }
@@ -4481,12 +4553,32 @@ 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)
 
@@ -4525,7 +4617,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("%s/lm_%04d", mapname, 0), false, false, false, NULL);
                if(!inpixels[0])
                        return;
 
@@ -4545,19 +4637,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("%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;
 
@@ -4570,51 +4662,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++)
-               {
-                       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)
+               // q3map2 sometimes (or always?) makes a second blank lightmap for no
+               // reason when only one lightmap is used, which can throw off the
+               // deluxemapping detection method, so check 2-lightmap bsp's specifically
+               // to see if the second lightmap is blank, if so it is not deluxemapped.
+               //
+               // further research has shown q3map2 sometimes creates a deluxemap and two
+               // blank lightmaps, which must be handled properly as well
+               if (endlightmap == 1 && count > 1)
                {
-                       // all pixels in the unused lightmap were black...
-                       loadmodel->brushq3.deluxemapping = false;
+                       c = inpixels[1];
+                       for (i = 0;i < size*size;i++)
+                       {
+                               if (c[bytesperpixel*i + rgbmap[0]])
+                                       break;
+                               if (c[bytesperpixel*i + rgbmap[1]])
+                                       break;
+                               if (c[bytesperpixel*i + rgbmap[2]])
+                                       break;
+                       }
+                       if (i == size*size)
+                       {
+                               // all pixels in the unused lightmap were black...
+                               loadmodel->brushq3.deluxemapping = false;
+                       }
                }
        }
 
@@ -4622,18 +4719,42 @@ 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<<bound(0, mod_q3bsp_lightmapmergepower.integer, 6);
+       mergegoal = bound(size, mergegoal, (int)vid.maxtexturesize_2d);
+       while (mergegoal > 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<<loadmodel->brushq3.num_lightmapmergedwidthpower)
+               loadmodel->brushq3.num_lightmapmergedwidthpower++;
+       while (mergedheight > size<<loadmodel->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 *));
@@ -4642,61 +4763,43 @@ static void Mod_Q3BSP_LoadLightmaps(lump_t *l, lump_t *faceslump)
        if (loadmodel->texturepool == NULL && cls.state != ca_dedicated)
                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)
+               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_Printf("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++)
                {
-                       // 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);
+                       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("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);
+                               loadmodel->brushq3.data_lightmaps [lightmapindex] = R_LoadTexture2D(loadmodel->texturepool, va("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)
@@ -4709,9 +4812,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)
@@ -4748,10 +4851,7 @@ static void Mod_Q3BSP_BuildBBoxes(const int *element3i, int num_triangles, const
                }
        }
        else
-       {
-               *collisionstride = 0;
                *collisionbbox6f = NULL;
-       }
 }
 
 typedef struct patchtess_s
@@ -4778,7 +4878,7 @@ static void Mod_Q3BSP_LoadFaces(lump_t *l)
 {
        q3dface_t *in, *oldin;
        msurface_t *out, *oldout;
-       int i, oldi, j, n, count, invalidelements, patchsize[2], finalwidth, finalheight, xtess, ytess, finalvertices, finaltriangles, firstvertex, firstelement, type, oldnumtriangles, oldnumtriangles2, meshvertices, meshtriangles, numvertices, numtriangles, 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;
@@ -4789,6 +4889,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;
@@ -4835,8 +4937,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)
@@ -4859,9 +4961,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;
                        }
                }
 
@@ -4930,18 +5033,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;
                }
@@ -4970,6 +5073,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);
@@ -4981,14 +5086,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);
+       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)
@@ -4999,6 +5121,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:
@@ -5052,7 +5175,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)
@@ -5065,40 +5188,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;
@@ -5174,9 +5319,16 @@ 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
@@ -5413,7 +5565,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));
@@ -5469,7 +5624,10 @@ static void Mod_Q3BSP_LightPoint(dp_model_t *model, const vec3_t p, vec3_t ambie
        q3dlightgrid_t *a, *s;
 
        // scale lighting by lightstyle[0] so that darkmode in dpmod works properly
-       stylescale = r_refdef.scene.rtlightstylevalue[0];
+       if (vid.renderpath == RENDERPATH_GL20)
+               stylescale = 1; // added while render
+       else
+               stylescale = r_refdef.scene.rtlightstylevalue[0];
 
        if (!model->brushq3.num_lightgrid)
        {
@@ -5527,161 +5685,799 @@ 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 void Mod_Q3BSP_TracePoint_RecursiveBSPNode(trace_t *trace, dp_model_t *model, mnode_t *node, const vec3_t point, int markframe)
+static int Mod_Q3BSP_TraceLineOfSight_RecursiveNodeCheck(mnode_t *node, double p1[3], double p2[3])
 {
-       int i;
-       mleaf_t *leaf;
-       colbrushf_t *brush;
-       // find which leaf the point is in
-       while (node->plane)
-               node = node->children[(node->plane->type < 3 ? point[node->plane->type] : DotProduct(point, node->plane->normal)) < node->plane->dist];
-       // point trace the brushes
-       leaf = (mleaf_t *)node;
-       for (i = 0;i < leaf->numleafbrushes;i++)
-       {
-               brush = model->brush.data_brushes[leaf->firstleafbrush[i]].colbrushf;
-               if (brush && brush->markframe != markframe && BoxesOverlap(point, point, brush->mins, brush->maxs))
-               {
-                       brush->markframe = markframe;
-                       Collision_TracePointBrushFloat(trace, point, brush);
-               }
-       }
-       // can't do point traces on curves (they have no thickness)
-}
+       double t1, t2;
+       double midf, mid[3];
+       int ret, side;
 
-static void Mod_Q3BSP_TraceLine_RecursiveBSPNode(trace_t *trace, dp_model_t *model, mnode_t *node, const vec3_t start, const vec3_t end, vec_t startfrac, vec_t endfrac, const vec3_t linestart, const vec3_t lineend, int markframe, const vec3_t segmentmins, const vec3_t segmentmaxs)
-{
-       int i, startside, endside;
-       float dist1, dist2, midfrac, mid[3], nodesegmentmins[3], nodesegmentmaxs[3];
-       mleaf_t *leaf;
-       msurface_t *surface;
-       mplane_t *plane;
-       colbrushf_t *brush;
-       // walk the tree until we hit a leaf, recursing for any split cases
+       // check for empty
        while (node->plane)
        {
-               // abort if this part of the bsp tree can not be hit by this trace
-//             if (!(node->combinedsupercontents & trace->hitsupercontentsmask))
-//                     return;
-               plane = node->plane;
-               // axial planes are much more common than non-axial, so an optimized
-               // axial case pays off here
+               // find the point distances
+               mplane_t *plane = node->plane;
                if (plane->type < 3)
                {
-                       dist1 = start[plane->type] - plane->dist;
-                       dist2 = end[plane->type] - plane->dist;
+                       t1 = p1[plane->type] - plane->dist;
+                       t2 = p2[plane->type] - plane->dist;
                }
                else
                {
-                       dist1 = DotProduct(start, plane->normal) - plane->dist;
-                       dist2 = DotProduct(end, plane->normal) - plane->dist;
+                       t1 = DotProduct (plane->normal, p1) - plane->dist;
+                       t2 = DotProduct (plane->normal, p2) - plane->dist;
                }
-               startside = dist1 < 0;
-               endside = dist2 < 0;
-               if (startside == endside)
+
+               if (t1 < 0)
                {
-                       // most of the time the line fragment is on one side of the plane
-                       node = node->children[startside];
+                       if (t2 < 0)
+                       {
+                               node = node->children[1];
+                               continue;
+                       }
+                       side = 1;
                }
                else
                {
-                       // line crosses node plane, split the line
-                       dist1 = PlaneDiff(linestart, plane);
-                       dist2 = PlaneDiff(lineend, plane);
-                       midfrac = dist1 / (dist1 - dist2);
-                       VectorLerp(linestart, midfrac, lineend, mid);
-                       // take the near side first
-                       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)
-                               Mod_Q3BSP_TraceLine_RecursiveBSPNode(trace, model, node->children[endside], mid, end, midfrac, endfrac, linestart, lineend, markframe, segmentmins, segmentmaxs);
-                       return;
+                       if (t2 >= 0)
+                       {
+                               node = node->children[0];
+                               continue;
+                       }
+                       side = 0;
                }
+
+               midf = t1 / (t1 - t2);
+               VectorLerp(p1, midf, p2, mid);
+
+               // recurse both sides, front side first
+               // return 2 if empty is followed by solid (hit something)
+               // do not return 2 if both are solid or both empty,
+               // or if start is solid and end is empty
+               // as these degenerate cases usually indicate the eye is in solid and
+               // should see the target point anyway
+               ret = Mod_Q3BSP_TraceLineOfSight_RecursiveNodeCheck(node->children[side    ], p1, mid);
+               if (ret != 0)
+                       return ret;
+               ret = Mod_Q3BSP_TraceLineOfSight_RecursiveNodeCheck(node->children[side ^ 1], mid, p2);
+               if (ret != 1)
+                       return ret;
+               return 2;
        }
-       // abort if this part of the bsp tree can not be hit by this trace
-//     if (!(node->combinedsupercontents & trace->hitsupercontentsmask))
-//             return;
-       // hit a leaf
-       nodesegmentmins[0] = min(start[0], end[0]) - 1;
-       nodesegmentmins[1] = min(start[1], end[1]) - 1;
-       nodesegmentmins[2] = min(start[2], end[2]) - 1;
-       nodesegmentmaxs[0] = max(start[0], end[0]) + 1;
-       nodesegmentmaxs[1] = max(start[1], end[1]) + 1;
-       nodesegmentmaxs[2] = max(start[2], end[2]) + 1;
-       // line trace the brushes
-       leaf = (mleaf_t *)node;
-       for (i = 0;i < leaf->numleafbrushes;i++)
+       return ((mleaf_t *)node)->clusterindex < 0;
+}
+
+static qboolean Mod_Q3BSP_TraceLineOfSight(struct model_s *model, const vec3_t start, const vec3_t end)
+{
+       if (model->brush.submodel || mod_q3bsp_tracelineofsight_brushes.integer)
        {
-               brush = model->brush.data_brushes[leaf->firstleafbrush[i]].colbrushf;
-               if (brush && brush->markframe != markframe && BoxesOverlap(nodesegmentmins, nodesegmentmaxs, brush->mins, brush->maxs))
-               {
-                       brush->markframe = markframe;
-                       Collision_TraceLineBrushFloat(trace, linestart, lineend, brush, brush);
-               }
+               trace_t trace;
+               model->TraceLine(model, NULL, NULL, &trace, start, end, SUPERCONTENTS_VISBLOCKERMASK);
+               return trace.fraction == 1;
        }
-       // can't do point traces on curves (they have no thickness)
-       if (leaf->containscollisionsurfaces && mod_q3bsp_curves_collisions.integer && !VectorCompare(start, end))
+       else
        {
-               // line trace the curves
-               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))
-                       {
-                               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);
-                       }
-               }
+               double tracestart[3], traceend[3];
+               VectorCopy(start, tracestart);
+               VectorCopy(end, traceend);
+               return !Mod_Q3BSP_TraceLineOfSight_RecursiveNodeCheck(model->brush.data_nodes, tracestart, traceend);
        }
 }
 
-static void Mod_Q3BSP_TraceBrush_RecursiveBSPNode(trace_t *trace, dp_model_t *model, mnode_t *node, const colbrushf_t *thisbrush_start, const colbrushf_t *thisbrush_end, int markframe, const vec3_t segmentmins, const vec3_t segmentmaxs)
+static void Mod_CollisionBIH_TracePoint_RecursiveBIHNode(trace_t *trace, dp_model_t *model, int nodenum, const vec3_t point)
 {
-       int i;
-       int sides;
-       mleaf_t *leaf;
-       colbrushf_t *brush;
-       msurface_t *surface;
-       mplane_t *plane;
-       float nodesegmentmins[3], nodesegmentmaxs[3];
-       // walk the tree until we hit a leaf, recursing for any split cases
-       while (node->plane)
+       const bih_leaf_t *leaf;
+       const bih_node_t *node;
+       const colbrushf_t *brush;
+       int axis;
+       while (nodenum >= 0)
+       {
+               node = model->collision_bih.nodes + nodenum;
+               axis = node->type - BIH_SPLITX;
+               if (point[axis] <= node->backmax)
+               {
+                       if (point[axis] >= node->frontmin)
+                               Mod_CollisionBIH_TracePoint_RecursiveBIHNode(trace, model, node->front, point);
+                       nodenum = node->back;
+               }
+               else if (point[axis] >= node->frontmin)
+                       nodenum = node->front;
+               else // no overlap with either child?  just return
+                       return;
+       }
+       if (!model->collision_bih.leafs)
+               return;
+       leaf = model->collision_bih.leafs + (-1-nodenum);
+       switch(leaf->type)
        {
-               // abort if this part of the bsp tree can not be hit by this trace
-//             if (!(node->combinedsupercontents & trace->hitsupercontentsmask))
-//                     return;
-               plane = node->plane;
-               // axial planes are much more common than non-axial, so an optimized
-               // axial case pays off here
-               if (plane->type < 3)
+       case BIH_BRUSH:
+               brush = model->brush.data_brushes[leaf->itemindex].colbrushf;
+               Collision_TracePointBrushFloat(trace, point, 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_TraceLine_RecursiveBIHNode(trace_t *trace, dp_model_t *model, int nodenum, const vec3_t start, const vec3_t end, const vec3_t linestart, const vec3_t lineend)
+{
+       const bih_leaf_t *leaf;
+       const bih_node_t *node;
+       const colbrushf_t *brush;
+       const int *e;
+       const texture_t *texture;
+       int axis;
+#define BIHLINECLIP
+#ifdef BIHLINECLIP
+       int sideflags;
+       vec_t frontdist1;
+       vec_t frontdist2;
+       vec_t frontfrac;
+       vec_t backdist1;
+       vec_t backdist2;
+       vec_t backfrac;
+       vec3_t clipped, newstart, newend;
+#endif
+       vec3_t segmentmins;
+       vec3_t segmentmaxs;
+       segmentmins[0] = min(start[0], end[0]);
+       segmentmins[1] = min(start[1], end[1]);
+       segmentmins[2] = min(start[2], end[2]);
+       segmentmaxs[0] = max(start[0], end[0]);
+       segmentmaxs[1] = max(start[1], end[1]);
+       segmentmaxs[2] = max(start[2], end[2]);
+       while (nodenum >= 0)
+       {
+               node = model->collision_bih.nodes + nodenum;
+#if 0
+               if (!BoxesOverlap(segmentmins, segmentmaxs, node->mins, node->maxs))
+                       return;
+#endif
+               axis = node->type - BIH_SPLITX;
+#if 0
+               if (segmentmins[axis] <= node->backmax)
                {
-                       // this is an axial plane, compare bounding box directly to it and
-                       // recurse sides accordingly
-                       // recurse down node sides
-                       // use an inlined axial BoxOnPlaneSide to slightly reduce overhead
-                       //sides = BoxOnPlaneSide(nodesegmentmins, nodesegmentmaxs, plane);
-                       //sides = ((segmentmaxs[plane->type] >= plane->dist) | ((segmentmins[plane->type] < plane->dist) << 1));
-                       sides = ((segmentmaxs[plane->type] >= plane->dist) + ((segmentmins[plane->type] < plane->dist) * 2));
+                       if (segmentmaxs[axis] >= node->frontmin)
+                               Mod_CollisionBIH_TraceLine_RecursiveBIHNode(trace, model, node->front, start, end, linestart, lineend);
+                       nodenum = node->back;
                }
+               else if (segmentmaxs[axis] >= node->frontmin)
+                       nodenum = node->front;
                else
+                       return; // trace falls between children
+#else
+               frontdist1 = start[axis] - node->frontmin;
+               frontdist2 = end[axis] - node->frontmin;
+               backdist1 = start[axis] - node->backmax;
+               backdist2 = end[axis] - node->backmax;
+               sideflags = 0;
+               if (frontdist1 < 0)
+                       sideflags |= 1;
+               if (frontdist2 < 0)
+                       sideflags |= 2;
+               if (backdist1 < 0)
+                       sideflags |= 4;
+               if (backdist2 < 0)
+                       sideflags |= 8;
+#if 0
+               if (sideflags & 12)
                {
-                       // this is a non-axial plane, so check if the start and end boxes
-                       // are both on one side of the plane to handle 'diagonal' cases
-                       sides = BoxOnPlaneSide(thisbrush_start->mins, thisbrush_start->maxs, plane) | BoxOnPlaneSide(thisbrush_end->mins, thisbrush_end->maxs, plane);
+                       if ((sideflags & 3) != 3)
+                               Mod_CollisionBIH_TraceLine_RecursiveBIHNode(trace, model, node->front, start, end, linestart, lineend);
+                       nodenum = node->back;
                }
-               if (sides == 3)
+               else if ((sideflags & 3) != 3)
+                       nodenum = node->front;
+               else
+                       return; // trace falls between children
+#else
+               switch(sideflags)
                {
-                       // segment crosses plane
-                       Mod_Q3BSP_TraceBrush_RecursiveBSPNode(trace, model, node->children[0], thisbrush_start, thisbrush_end, markframe, segmentmins, segmentmaxs);
-                       sides = 2;
+               case 0:
+                       // start end START END
+                       nodenum = node->front;
+                       continue;
+               case 1:
+                       // START end START END
+#ifdef BIHLINECLIP
+                       frontfrac = frontdist1 / (frontdist1 - frontdist2);
+                       VectorLerp(start, frontfrac, end, newstart); start = newstart;
+                       segmentmins[0] = min(start[0], end[0]);
+                       segmentmins[1] = min(start[1], end[1]);
+                       segmentmins[2] = min(start[2], end[2]);
+                       segmentmaxs[0] = max(start[0], end[0]);
+                       segmentmaxs[1] = max(start[1], end[1]);
+                       segmentmaxs[2] = max(start[2], end[2]);
+#endif
+                       nodenum = node->front;
+                       break;
+               case 2:
+#ifdef BIHLINECLIP
+                       // start END START END
+                       frontfrac = frontdist1 / (frontdist1 - frontdist2);
+                       VectorLerp(start, frontfrac, end, newend); end = newend;
+                       segmentmins[0] = min(start[0], end[0]);
+                       segmentmins[1] = min(start[1], end[1]);
+                       segmentmins[2] = min(start[2], end[2]);
+                       segmentmaxs[0] = max(start[0], end[0]);
+                       segmentmaxs[1] = max(start[1], end[1]);
+                       segmentmaxs[2] = max(start[2], end[2]);
+#endif
+                       nodenum = node->front;
+                       break;
+               case 3:
+                       // START END START END
+                       return; // line falls in gap between children
+               case 4:
+                       // start end start END
+                       Mod_CollisionBIH_TraceLine_RecursiveBIHNode(trace, model, node->front, start, end, linestart, lineend);
+#ifdef BIHLINECLIP
+                       backfrac = backdist1 / (backdist1 - backdist2);
+                       VectorLerp(start, backfrac, end, newend); end = newend;
+                       segmentmins[0] = min(start[0], end[0]);
+                       segmentmins[1] = min(start[1], end[1]);
+                       segmentmins[2] = min(start[2], end[2]);
+                       segmentmaxs[0] = max(start[0], end[0]);
+                       segmentmaxs[1] = max(start[1], end[1]);
+                       segmentmaxs[2] = max(start[2], end[2]);
+#endif
+                       nodenum = node->back;
+                       break;
+               case 5:
+                       // START end start END
+#ifdef BIHLINECLIP
+                       frontfrac = frontdist1 / (frontdist1 - frontdist2);
+                       VectorLerp(start, frontfrac, end, clipped);
+                       Mod_CollisionBIH_TraceLine_RecursiveBIHNode(trace, model, node->front, clipped, end, linestart, lineend);
+                       backfrac = backdist1 / (backdist1 - backdist2);
+                       VectorLerp(start, backfrac, end, newend); end = newend;
+                       segmentmins[0] = min(start[0], end[0]);
+                       segmentmins[1] = min(start[1], end[1]);
+                       segmentmins[2] = min(start[2], end[2]);
+                       segmentmaxs[0] = max(start[0], end[0]);
+                       segmentmaxs[1] = max(start[1], end[1]);
+                       segmentmaxs[2] = max(start[2], end[2]);
+#else
+                       Mod_CollisionBIH_TraceLine_RecursiveBIHNode(trace, model, node->front, start, end, linestart, lineend);
+#endif
+                       nodenum = node->back;
+                       break;
+               case 6:
+                       // start END start END
+#ifdef BIHLINECLIP
+                       frontfrac = frontdist1 / (frontdist1 - frontdist2);
+                       VectorLerp(start, frontfrac, end, clipped);
+                       Mod_CollisionBIH_TraceLine_RecursiveBIHNode(trace, model, node->front, start, clipped, linestart, lineend);
+                       backfrac = backdist1 / (backdist1 - backdist2);
+                       VectorLerp(start, backfrac, end, newend); end = newend;
+                       segmentmins[0] = min(start[0], end[0]);
+                       segmentmins[1] = min(start[1], end[1]);
+                       segmentmins[2] = min(start[2], end[2]);
+                       segmentmaxs[0] = max(start[0], end[0]);
+                       segmentmaxs[1] = max(start[1], end[1]);
+                       segmentmaxs[2] = max(start[2], end[2]);
+#else
+                       Mod_CollisionBIH_TraceLine_RecursiveBIHNode(trace, model, node->front, start, end, linestart, lineend);
+#endif
+                       nodenum = node->back;
+                       break;
+               case 7:
+                       // START END start END
+#ifdef BIHLINECLIP
+                       backfrac = backdist1 / (backdist1 - backdist2);
+                       VectorLerp(start, backfrac, end, newend); end = newend;
+                       segmentmins[0] = min(start[0], end[0]);
+                       segmentmins[1] = min(start[1], end[1]);
+                       segmentmins[2] = min(start[2], end[2]);
+                       segmentmaxs[0] = max(start[0], end[0]);
+                       segmentmaxs[1] = max(start[1], end[1]);
+                       segmentmaxs[2] = max(start[2], end[2]);
+#endif
+                       nodenum = node->back;
+                       break;
+               case 8:
+                       // start end START end
+                       Mod_CollisionBIH_TraceLine_RecursiveBIHNode(trace, model, node->front, start, end, linestart, lineend);
+#ifdef BIHLINECLIP
+                       backfrac = backdist1 / (backdist1 - backdist2);
+                       VectorLerp(start, backfrac, end, newstart); start = newstart;
+                       segmentmins[0] = min(start[0], end[0]);
+                       segmentmins[1] = min(start[1], end[1]);
+                       segmentmins[2] = min(start[2], end[2]);
+                       segmentmaxs[0] = max(start[0], end[0]);
+                       segmentmaxs[1] = max(start[1], end[1]);
+                       segmentmaxs[2] = max(start[2], end[2]);
+#endif
+                       nodenum = node->back;
+                       break;
+               case 9:
+                       // START end START end
+#ifdef BIHLINECLIP
+                       frontfrac = frontdist1 / (frontdist1 - frontdist2);
+                       VectorLerp(start, frontfrac, end, clipped);
+                       Mod_CollisionBIH_TraceLine_RecursiveBIHNode(trace, model, node->front, clipped, end, linestart, lineend);
+                       backfrac = backdist1 / (backdist1 - backdist2);
+                       VectorLerp(start, backfrac, end, newstart); start = newstart;
+                       segmentmins[0] = min(start[0], end[0]);
+                       segmentmins[1] = min(start[1], end[1]);
+                       segmentmins[2] = min(start[2], end[2]);
+                       segmentmaxs[0] = max(start[0], end[0]);
+                       segmentmaxs[1] = max(start[1], end[1]);
+                       segmentmaxs[2] = max(start[2], end[2]);
+#else
+                       Mod_CollisionBIH_TraceLine_RecursiveBIHNode(trace, model, node->front, start, end, linestart, lineend);
+#endif
+                       nodenum = node->back;
+                       break;
+               case 10:
+                       // start END START end
+#ifdef BIHLINECLIP
+                       frontfrac = frontdist1 / (frontdist1 - frontdist2);
+                       VectorLerp(start, frontfrac, end, clipped);
+                       Mod_CollisionBIH_TraceLine_RecursiveBIHNode(trace, model, node->front, start, clipped, linestart, lineend);
+                       backfrac = backdist1 / (backdist1 - backdist2);
+                       VectorLerp(start, backfrac, end, newstart); start = newstart;
+                       segmentmins[0] = min(start[0], end[0]);
+                       segmentmins[1] = min(start[1], end[1]);
+                       segmentmins[2] = min(start[2], end[2]);
+                       segmentmaxs[0] = max(start[0], end[0]);
+                       segmentmaxs[1] = max(start[1], end[1]);
+                       segmentmaxs[2] = max(start[2], end[2]);
+#else
+                       Mod_CollisionBIH_TraceLine_RecursiveBIHNode(trace, model, node->front, start, end, linestart, lineend);
+#endif
+                       nodenum = node->back;
+                       break;
+               case 11:
+                       // START END START end
+#ifdef BIHLINECLIP
+                       backfrac = backdist1 / (backdist1 - backdist2);
+                       VectorLerp(start, backfrac, end, newstart); start = newstart;
+                       segmentmins[0] = min(start[0], end[0]);
+                       segmentmins[1] = min(start[1], end[1]);
+                       segmentmins[2] = min(start[2], end[2]);
+                       segmentmaxs[0] = max(start[0], end[0]);
+                       segmentmaxs[1] = max(start[1], end[1]);
+                       segmentmaxs[2] = max(start[2], end[2]);
+#endif
+                       nodenum = node->back;
+                       break;
+               case 12:
+                       // start end start end
+                       Mod_CollisionBIH_TraceLine_RecursiveBIHNode(trace, model, node->front, start, end, linestart, lineend);
+                       nodenum = node->back;
+                       break;
+               case 13:
+                       // START end start end
+#ifdef BIHLINECLIP
+                       frontfrac = frontdist1 / (frontdist1 - frontdist2);
+                       VectorLerp(start, frontfrac, end, clipped);
+                       Mod_CollisionBIH_TraceLine_RecursiveBIHNode(trace, model, node->front, clipped, end, linestart, lineend);
+#else
+                       Mod_CollisionBIH_TraceLine_RecursiveBIHNode(trace, model, node->front, start, end, linestart, lineend);
+#endif
+                       nodenum = node->back;
+                       break;
+               case 14:
+                       // start END start end
+#ifdef BIHLINECLIP
+                       frontfrac = frontdist1 / (frontdist1 - frontdist2);
+                       VectorLerp(start, frontfrac, end, clipped);
+                       Mod_CollisionBIH_TraceLine_RecursiveBIHNode(trace, model, node->front, start, clipped, linestart, lineend);
+#else
+                       Mod_CollisionBIH_TraceLine_RecursiveBIHNode(trace, model, node->front, start, end, linestart, lineend);
+#endif
+                       nodenum = node->back;
+                       break;
+               case 15:
+                       // START END start end
+                       nodenum = node->back;
+                       continue;
                }
-               // if sides == 0 then the trace itself is bogus (Not A Number values),
-               // in this case we simply pretend the trace hit nothing
-               if (sides == 0)
-                       return; // ERROR: NAN bounding box!
-               // take whichever side the segment box is on
-               node = node->children[sides - 1];
+#endif
+#endif
+       }
+       if (!model->collision_bih.leafs)
+               return;
+       leaf = model->collision_bih.leafs + (-1-nodenum);
+#if 1
+       if (!BoxesOverlap(segmentmins, segmentmaxs, leaf->mins, leaf->maxs))
+               return;
+#endif
+       switch(leaf->type)
+       {
+       case BIH_BRUSH:
+               brush = model->brush.data_brushes[leaf->itemindex].colbrushf;
+               Collision_TraceLineBrushFloat(trace, linestart, lineend, brush, brush);
+               break;
+       case BIH_COLLISIONTRIANGLE:
+               if (!mod_q3bsp_curves_collisions.integer)
+                       return;
+               e = model->brush.data_collisionelement3i + 3*leaf->itemindex;
+               texture = model->data_textures + leaf->textureindex;
+               Collision_TraceLineTriangleFloat(trace, linestart, lineend, 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, linestart, lineend, 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;
+       }
+}
+
+static void Mod_CollisionBIH_TraceBrush_RecursiveBIHNode(trace_t *trace, dp_model_t *model, int nodenum, const colbrushf_t *thisbrush_start, const colbrushf_t *thisbrush_end, const vec3_t segmentmins, const vec3_t segmentmaxs)
+{
+       const bih_leaf_t *leaf;
+       const bih_node_t *node;
+       const colbrushf_t *brush;
+       const int *e;
+       const texture_t *texture;
+       int axis;
+       while (nodenum >= 0)
+       {
+               node = model->collision_bih.nodes + nodenum;
+               axis = node->type - BIH_SPLITX;
+#if 1
+               if (!BoxesOverlap(segmentmins, segmentmaxs, node->mins, node->maxs))
+                       return;
+#endif
+#if 0
+               Mod_CollisionBIH_TraceBrush_RecursiveBIHNode(trace, model, node->front, thisbrush_start, thisbrush_end, segmentmins, segmentmaxs);
+               nodenum = node->back;
+               continue;
+#endif
+               if (segmentmins[axis] <= node->backmax)
+               {
+                       if (segmentmaxs[axis] >= node->frontmin)
+                               Mod_CollisionBIH_TraceBrush_RecursiveBIHNode(trace, model, node->front, thisbrush_start, thisbrush_end, segmentmins, segmentmaxs);
+                       nodenum = node->back;
+               }
+               else if (segmentmaxs[axis] >= node->frontmin)
+                       nodenum = node->front;
+               else
+                       return; // trace falls between children
+       }
+       if (!model->collision_bih.leafs)
+               return;
+       leaf = model->collision_bih.leafs + (-1-nodenum);
+#if 1
+       if (!BoxesOverlap(segmentmins, segmentmaxs, leaf->mins, leaf->maxs))
+               return;
+#endif
+       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)
+                       return;
+               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_TracePoint(dp_model_t *model, const frameblend_t *frameblend, const skeleton_t *skeleton, trace_t *trace, const vec3_t start, int hitsupercontentsmask)
+{
+       memset(trace, 0, sizeof(*trace));
+       trace->fraction = 1;
+       trace->realfraction = 1;
+       trace->hitsupercontentsmask = hitsupercontentsmask;
+       Mod_CollisionBIH_TracePoint_RecursiveBIHNode(trace, model, model->collision_bih.rootnode, start);
+}
+
+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)
+{
+       if (VectorCompare(start, end))
+       {
+               Mod_CollisionBIH_TracePoint(model, frameblend, skeleton, trace, start, hitsupercontentsmask);
+               return;
+       }
+
+       memset(trace, 0, sizeof(*trace));
+       trace->fraction = 1;
+       trace->realfraction = 1;
+       trace->hitsupercontentsmask = hitsupercontentsmask;
+       Mod_CollisionBIH_TraceLine_RecursiveBIHNode(trace, model, model->collision_bih.rootnode, start, end, start, end);
+}
+
+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)
+{
+       float segmentmins[3], segmentmaxs[3];
+       colboxbrushf_t thisbrush_start, thisbrush_end;
+       vec3_t boxstartmins, boxstartmaxs, boxendmins, boxendmaxs;
+
+       if (mod_q3bsp_optimizedtraceline.integer && VectorCompare(boxmins, boxmaxs))
+       {
+               vec3_t shiftstart, shiftend;
+               VectorAdd(start, boxmins, shiftstart);
+               VectorAdd(end, boxmins, shiftend);
+               if (VectorCompare(start, end))
+                       Mod_CollisionBIH_TracePoint(model, frameblend, skeleton, trace, shiftstart, hitsupercontentsmask);
+               else
+                       Mod_CollisionBIH_TraceLine(model, frameblend, skeleton, trace, shiftstart, shiftend, hitsupercontentsmask);
+               return;
+       }
+
+       // box trace, performed as brush trace
+       memset(trace, 0, sizeof(*trace));
+       trace->fraction = 1;
+       trace->realfraction = 1;
+       trace->hitsupercontentsmask = hitsupercontentsmask;
+       segmentmins[0] = min(start[0], end[0]) + boxmins[0] - 1;
+       segmentmins[1] = min(start[1], end[1]) + boxmins[1] - 1;
+       segmentmins[2] = min(start[2], end[2]) + boxmins[2] - 1;
+       segmentmaxs[0] = max(start[0], end[0]) + boxmaxs[0] + 1;
+       segmentmaxs[1] = max(start[1], end[1]) + boxmaxs[1] + 1;
+       segmentmaxs[2] = max(start[2], end[2]) + boxmaxs[2] + 1;
+       VectorAdd(start, boxmins, boxstartmins);
+       VectorAdd(start, boxmaxs, boxstartmaxs);
+       VectorAdd(end, boxmins, boxendmins);
+       VectorAdd(end, boxmaxs, boxendmaxs);
+       Collision_BrushForBox(&thisbrush_start, boxstartmins, boxstartmaxs, 0, 0, NULL);
+       Collision_BrushForBox(&thisbrush_end, boxendmins, boxendmaxs, 0, 0, NULL);
+       Mod_CollisionBIH_TraceBrush_RecursiveBIHNode(trace, model, model->collision_bih.rootnode, &thisbrush_start.brush, &thisbrush_end.brush, segmentmins, segmentmaxs);
+}
+
+void Mod_CollisionBIH_TraceBrush(dp_model_t *model, const frameblend_t *frameblend, const skeleton_t *skeleton, trace_t *trace, colbrushf_t *start, colbrushf_t *end, int hitsupercontentsmask)
+{
+       float segmentmins[3], segmentmaxs[3];
+
+       if (mod_q3bsp_optimizedtraceline.integer && VectorCompare(start->mins, start->maxs) && VectorCompare(end->mins, end->maxs))
+       {
+               if (VectorCompare(start->mins, end->mins))
+                       Mod_CollisionBIH_TracePoint(model, frameblend, skeleton, trace, start->mins, hitsupercontentsmask);
+               else
+                       Mod_CollisionBIH_TraceLine(model, frameblend, skeleton, trace, start->mins, end->mins, hitsupercontentsmask);
+               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->mins[0], end->mins[0]);
+       segmentmins[1] = min(start->mins[1], end->mins[1]);
+       segmentmins[2] = min(start->mins[2], end->mins[2]);
+       segmentmaxs[0] = max(start->maxs[0], end->maxs[0]);
+       segmentmaxs[1] = max(start->maxs[1], end->maxs[1]);
+       segmentmaxs[2] = max(start->maxs[2], end->maxs[2]);
+       Mod_CollisionBIH_TraceBrush_RecursiveBIHNode(trace, model, model->collision_bih.rootnode, start, end, segmentmins, segmentmaxs);
+}
+
+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);
+       return trace.startsupercontents;
+}
+
+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)
+{
+#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->realfraction = 1;
+       trace->hitsupercontentsmask = hitsupercontentsmask;
+#if 0
+       Mod_CollisionBIH_TraceLine_RecursiveBIHNode(trace, model, model->collision_bih.rootnode, start, end, start, end);
+       hitsupercontents = trace->hitsupercontents;
+       memset(trace, 0, sizeof(*trace));
+       trace->fraction = 1;
+       trace->realfraction = 1;
+       trace->hitsupercontentsmask = hitsupercontentsmask;
+       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.realfraction = 1;
+       trace.hitsupercontentsmask = 0;
+       Mod_CollisionBIH_TraceLine_RecursiveBIHNode(&trace, model, model->collision_bih.rootnode, start, end, start, end);
+       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;
+       mleaf_t *leaf;
+       colbrushf_t *brush;
+       // find which leaf the point is in
+       while (node->plane)
+               node = node->children[(node->plane->type < 3 ? point[node->plane->type] : DotProduct(point, node->plane->normal)) < node->plane->dist];
+       // point trace the brushes
+       leaf = (mleaf_t *)node;
+       for (i = 0;i < leaf->numleafbrushes;i++)
+       {
+               brush = model->brush.data_brushes[leaf->firstleafbrush[i]].colbrushf;
+               if (brush && brush->markframe != markframe && BoxesOverlap(point, point, brush->mins, brush->maxs))
+               {
+                       brush->markframe = markframe;
+                       Collision_TracePointBrushFloat(trace, point, brush);
+               }
+       }
+       // can't do point traces on curves (they have no thickness)
+}
+
+static void Mod_Q3BSP_TraceLine_RecursiveBSPNode(trace_t *trace, dp_model_t *model, mnode_t *node, const vec3_t start, const vec3_t end, vec_t startfrac, vec_t endfrac, const vec3_t linestart, const vec3_t lineend, int markframe, const vec3_t segmentmins, const vec3_t segmentmaxs)
+{
+       int i, startside, endside;
+       float dist1, dist2, midfrac, mid[3], nodesegmentmins[3], nodesegmentmaxs[3];
+       mleaf_t *leaf;
+       msurface_t *surface;
+       mplane_t *plane;
+       colbrushf_t *brush;
+       // 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;
+               plane = node->plane;
+               // axial planes are much more common than non-axial, so an optimized
+               // axial case pays off here
+               if (plane->type < 3)
+               {
+                       dist1 = start[plane->type] - plane->dist;
+                       dist2 = end[plane->type] - plane->dist;
+               }
+               else
+               {
+                       dist1 = DotProduct(start, plane->normal) - plane->dist;
+                       dist2 = DotProduct(end, plane->normal) - plane->dist;
+               }
+               startside = dist1 < 0;
+               endside = dist2 < 0;
+               if (startside == endside)
+               {
+                       // most of the time the line fragment is on one side of the plane
+                       node = node->children[startside];
+               }
+               else
+               {
+                       // line crosses node plane, split the line
+                       dist1 = PlaneDiff(linestart, plane);
+                       dist2 = PlaneDiff(lineend, plane);
+                       midfrac = dist1 / (dist1 - dist2);
+                       VectorLerp(linestart, midfrac, lineend, mid);
+                       // take the near side first
+                       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)
+                               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))
+//             return;
+       // hit a leaf
+       nodesegmentmins[0] = min(start[0], end[0]) - 1;
+       nodesegmentmins[1] = min(start[1], end[1]) - 1;
+       nodesegmentmins[2] = min(start[2], end[2]) - 1;
+       nodesegmentmaxs[0] = max(start[0], end[0]) + 1;
+       nodesegmentmaxs[1] = max(start[1], end[1]) + 1;
+       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;
+               if (brush && brush->markframe != markframe && BoxesOverlap(nodesegmentmins, nodesegmentmaxs, brush->mins, brush->maxs))
+               {
+                       brush->markframe = markframe;
+                       Collision_TraceLineBrushFloat(trace, linestart, lineend, brush, brush);
+               }
+       }
+       // can't do point traces on curves (they have no thickness)
+       if (leaf->containscollisionsurfaces && mod_q3bsp_curves_collisions.integer && !VectorCompare(start, end))
+       {
+               // line trace the curves
+               for (i = 0;i < leaf->numleafsurfaces;i++)
+               {
+                       surface = model->data_surfaces + leaf->firstleafsurface[i];
+                       if (surface->num_collisiontriangles && surface->deprecatedq3collisionmarkframe != markframe && BoxesOverlap(nodesegmentmins, nodesegmentmaxs, surface->mins, surface->maxs))
+                       {
+                               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);
+                       }
+               }
+       }
+}
+
+static void Mod_Q3BSP_TraceBrush_RecursiveBSPNode(trace_t *trace, dp_model_t *model, mnode_t *node, const colbrushf_t *thisbrush_start, const colbrushf_t *thisbrush_end, int markframe, const vec3_t segmentmins, const vec3_t segmentmaxs)
+{
+       int i;
+       int sides;
+       mleaf_t *leaf;
+       colbrushf_t *brush;
+       msurface_t *surface;
+       mplane_t *plane;
+       float nodesegmentmins[3], nodesegmentmaxs[3];
+       // 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;
+               plane = node->plane;
+               // axial planes are much more common than non-axial, so an optimized
+               // axial case pays off here
+               if (plane->type < 3)
+               {
+                       // this is an axial plane, compare bounding box directly to it and
+                       // recurse sides accordingly
+                       // recurse down node sides
+                       // use an inlined axial BoxOnPlaneSide to slightly reduce overhead
+                       //sides = BoxOnPlaneSide(nodesegmentmins, nodesegmentmaxs, plane);
+                       //sides = ((segmentmaxs[plane->type] >= plane->dist) | ((segmentmins[plane->type] < plane->dist) << 1));
+                       sides = ((segmentmaxs[plane->type] >= plane->dist) + ((segmentmins[plane->type] < plane->dist) * 2));
+               }
+               else
+               {
+                       // this is a non-axial plane, so check if the start and end boxes
+                       // are both on one side of the plane to handle 'diagonal' cases
+                       sides = BoxOnPlaneSide(thisbrush_start->mins, thisbrush_start->maxs, plane) | BoxOnPlaneSide(thisbrush_end->mins, thisbrush_end->maxs, plane);
+               }
+               if (sides == 3)
+               {
+                       // segment crosses plane
+                       Mod_Q3BSP_TraceBrush_RecursiveBSPNode(trace, model, node->children[0], thisbrush_start, thisbrush_end, markframe, segmentmins, segmentmaxs);
+                       sides = 2;
+               }
+               // if sides == 0 then the trace itself is bogus (Not A Number values),
+               // in this case we simply pretend the trace hit nothing
+               if (sides == 0)
+                       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))
@@ -5694,6 +6490,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;
@@ -5708,96 +6508,172 @@ 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 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 int markframe = 0;
+
+static void Mod_Q3BSP_TracePoint(dp_model_t *model, const frameblend_t *frameblend, const skeleton_t *skeleton, trace_t *trace, const vec3_t start, int hitsupercontentsmask)
+{
+       int i;
+       q3mbrush_t *brush;
+       memset(trace, 0, sizeof(*trace));
+       trace->fraction = 1;
+       trace->realfraction = 1;
+       trace->hitsupercontentsmask = hitsupercontentsmask;
+       if (mod_collision_bih.integer)
+               Mod_CollisionBIH_TracePoint_RecursiveBIHNode(trace, model, model->collision_bih.rootnode, start);
+       else if (model->brush.submodel)
+       {
+               for (i = 0, brush = model->brush.data_brushes + model->firstmodelbrush;i < model->nummodelbrushes;i++, brush++)
+                       if (brush->colbrushf)
+                               Collision_TracePointBrushFloat(trace, start, brush->colbrushf);
+       }
+       else
+               Mod_Q3BSP_TracePoint_RecursiveBSPNode(trace, model, model->brush.data_nodes, start, ++markframe);
+}
+
+static void Mod_Q3BSP_TraceLine(dp_model_t *model, const frameblend_t *frameblend, const skeleton_t *skeleton, trace_t *trace, const vec3_t start, const vec3_t end, int hitsupercontentsmask)
+{
+       int i;
+       float segmentmins[3], segmentmaxs[3];
+       msurface_t *surface;
+       q3mbrush_t *brush;
+
+       if (VectorCompare(start, end))
+       {
+               Mod_Q3BSP_TracePoint(model, frameblend, skeleton, trace, start, hitsupercontentsmask);
+               return;
+       }
+
+       memset(trace, 0, sizeof(*trace));
+       trace->fraction = 1;
+       trace->realfraction = 1;
+       trace->hitsupercontentsmask = hitsupercontentsmask;
+       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 (mod_collision_bih.integer)
+               Mod_CollisionBIH_TraceLine_RecursiveBIHNode(trace, model, model->collision_bih.rootnode, start, end, start, end);
+       else if (model->brush.submodel)
+       {
+               for (i = 0, brush = model->brush.data_brushes + model->firstmodelbrush;i < model->nummodelbrushes;i++, brush++)
+                       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 && 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, const frameblend_t *frameblend, const skeleton_t *skeleton, trace_t *trace, const vec3_t start, const vec3_t boxmins, const vec3_t boxmaxs, const vec3_t end, int hitsupercontentsmask)
 {
        int i;
-       vec3_t shiftstart, shiftend;
        float segmentmins[3], segmentmaxs[3];
-       static int markframe = 0;
        msurface_t *surface;
        q3mbrush_t *brush;
+       colboxbrushf_t thisbrush_start, thisbrush_end;
+       vec3_t boxstartmins, boxstartmaxs, boxendmins, boxendmaxs;
+
+       if (mod_q3bsp_optimizedtraceline.integer && VectorCompare(boxmins, boxmaxs))
+       {
+               vec3_t shiftstart, shiftend;
+               VectorAdd(start, boxmins, shiftstart);
+               VectorAdd(end, boxmins, shiftend);
+               if (VectorCompare(start, end))
+                       Mod_Q3BSP_TracePoint(model, frameblend, skeleton, trace, shiftstart, hitsupercontentsmask);
+               else
+                       Mod_Q3BSP_TraceLine(model, frameblend, skeleton, trace, shiftstart, shiftend, hitsupercontentsmask);
+               return;
+       }
+
+       // box trace, performed as brush trace
+       memset(trace, 0, sizeof(*trace));
+       trace->fraction = 1;
+       trace->realfraction = 1;
+       trace->hitsupercontentsmask = hitsupercontentsmask;
+       segmentmins[0] = min(start[0], end[0]) + boxmins[0] - 1;
+       segmentmins[1] = min(start[1], end[1]) + boxmins[1] - 1;
+       segmentmins[2] = min(start[2], end[2]) + boxmins[2] - 1;
+       segmentmaxs[0] = max(start[0], end[0]) + boxmaxs[0] + 1;
+       segmentmaxs[1] = max(start[1], end[1]) + boxmaxs[1] + 1;
+       segmentmaxs[2] = max(start[2], end[2]) + boxmaxs[2] + 1;
+       VectorAdd(start, boxmins, boxstartmins);
+       VectorAdd(start, boxmaxs, boxstartmaxs);
+       VectorAdd(end, boxmins, boxendmins);
+       VectorAdd(end, boxmaxs, boxendmaxs);
+       Collision_BrushForBox(&thisbrush_start, boxstartmins, boxstartmaxs, 0, 0, NULL);
+       Collision_BrushForBox(&thisbrush_end, boxendmins, boxendmaxs, 0, 0, NULL);
+       if (mod_collision_bih.integer)
+               Mod_CollisionBIH_TraceBrush_RecursiveBIHNode(trace, model, model->collision_bih.rootnode, &thisbrush_start.brush, &thisbrush_end.brush, segmentmins, segmentmaxs);
+       else if (model->brush.submodel)
+       {
+               for (i = 0, brush = model->brush.data_brushes + model->firstmodelbrush;i < model->nummodelbrushes;i++, brush++)
+                       if (brush->colbrushf && BoxesOverlap(segmentmins, segmentmaxs, brush->colbrushf->mins, brush->colbrushf->maxs))
+                               Collision_TraceBrushBrushFloat(trace, &thisbrush_start.brush, &thisbrush_end.brush, brush->colbrushf, brush->colbrushf);
+               if (mod_q3bsp_curves_collisions.integer)
+                       for (i = 0, surface = model->data_surfaces + model->firstmodelsurface;i < model->nummodelsurfaces;i++, surface++)
+                               if (surface->num_collisiontriangles && BoxesOverlap(segmentmins, segmentmaxs, surface->mins, surface->maxs))
+                                       Collision_TraceBrushTriangleMeshFloat(trace, &thisbrush_start.brush, &thisbrush_end.brush, 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.brush, &thisbrush_end.brush, ++markframe, segmentmins, segmentmaxs);
+}
+
+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)
+{
+       float segmentmins[3], segmentmaxs[3];
+       int i;
+       msurface_t *surface;
+       q3mbrush_t *brush;
+
+       if (mod_q3bsp_optimizedtraceline.integer && VectorCompare(start->mins, start->maxs) && VectorCompare(end->mins, end->maxs))
+       {
+               if (VectorCompare(start->mins, end->mins))
+                       Mod_Q3BSP_TracePoint(model, frameblend, skeleton, trace, start->mins, hitsupercontentsmask);
+               else
+                       Mod_Q3BSP_TraceLine(model, frameblend, skeleton, trace, start->mins, end->mins, hitsupercontentsmask);
+               return;
+       }
+
+       // box trace, performed as brush trace
        memset(trace, 0, sizeof(*trace));
        trace->fraction = 1;
        trace->realfraction = 1;
        trace->hitsupercontentsmask = hitsupercontentsmask;
-       if (mod_q3bsp_optimizedtraceline.integer && VectorCompare(boxmins, boxmaxs))
+       segmentmins[0] = min(start->mins[0], end->mins[0]);
+       segmentmins[1] = min(start->mins[1], end->mins[1]);
+       segmentmins[2] = min(start->mins[2], end->mins[2]);
+       segmentmaxs[0] = max(start->maxs[0], end->maxs[0]);
+       segmentmaxs[1] = max(start->maxs[1], end->maxs[1]);
+       segmentmaxs[2] = max(start->maxs[2], end->maxs[2]);
+       if (mod_collision_bih.integer)
+               Mod_CollisionBIH_TraceBrush_RecursiveBIHNode(trace, model, model->collision_bih.rootnode, start, end, segmentmins, segmentmaxs);
+       else if (model->brush.submodel)
        {
-               VectorAdd(start, boxmins, shiftstart);
-               VectorAdd(end, boxmins, shiftend);
-               if (VectorCompare(shiftstart, shiftend))
-               {
-                       // point trace
-                       if (model->brush.submodel)
-                       {
-                               for (i = 0, brush = model->brush.data_brushes + model->firstmodelbrush;i < model->nummodelbrushes;i++, brush++)
-                                       if (brush->colbrushf)
-                                               Collision_TracePointBrushFloat(trace, shiftstart, brush->colbrushf);
-                       }
-                       else
-                               Mod_Q3BSP_TracePoint_RecursiveBSPNode(trace, model, model->brush.data_nodes, shiftstart, ++markframe);
-               }
-               else
-               {
-                       // line trace
-                       segmentmins[0] = min(shiftstart[0], shiftend[0]) - 1;
-                       segmentmins[1] = min(shiftstart[1], shiftend[1]) - 1;
-                       segmentmins[2] = min(shiftstart[2], shiftend[2]) - 1;
-                       segmentmaxs[0] = max(shiftstart[0], shiftend[0]) + 1;
-                       segmentmaxs[1] = max(shiftstart[1], shiftend[1]) + 1;
-                       segmentmaxs[2] = max(shiftstart[2], shiftend[2]) + 1;
-                       if (model->brush.submodel)
-                       {
-                               for (i = 0, brush = model->brush.data_brushes + model->firstmodelbrush;i < model->nummodelbrushes;i++, brush++)
-                                       if (brush->colbrushf)
-                                               Collision_TraceLineBrushFloat(trace, shiftstart, shiftend, 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, shiftstart, shiftend, surface->num_collisiontriangles, surface->data_collisionelement3i, surface->data_collisionvertex3f, surface->num_collisionbboxstride, surface->data_collisionbbox6f, surface->texture->supercontents, surface->texture->surfaceflags, surface->texture, segmentmins, segmentmaxs);
-                       }
-                       else
-                               Mod_Q3BSP_TraceLine_RecursiveBSPNode(trace, model, model->brush.data_nodes, shiftstart, shiftend, 0, 1, shiftstart, shiftend, ++markframe, segmentmins, segmentmaxs);
-               }
+               for (i = 0, brush = model->brush.data_brushes + model->firstmodelbrush;i < model->nummodelbrushes;i++, brush++)
+                       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 && 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
-       {
-               // box trace, performed as brush trace
-               colbrushf_t *thisbrush_start, *thisbrush_end;
-               vec3_t boxstartmins, boxstartmaxs, boxendmins, boxendmaxs;
-               segmentmins[0] = min(start[0], end[0]) + boxmins[0] - 1;
-               segmentmins[1] = min(start[1], end[1]) + boxmins[1] - 1;
-               segmentmins[2] = min(start[2], end[2]) + boxmins[2] - 1;
-               segmentmaxs[0] = max(start[0], end[0]) + boxmaxs[0] + 1;
-               segmentmaxs[1] = max(start[1], end[1]) + boxmaxs[1] + 1;
-               segmentmaxs[2] = max(start[2], end[2]) + boxmaxs[2] + 1;
-               VectorAdd(start, boxmins, boxstartmins);
-               VectorAdd(start, boxmaxs, boxstartmaxs);
-               VectorAdd(end, boxmins, boxendmins);
-               VectorAdd(end, boxmaxs, boxendmaxs);
-               thisbrush_start = Collision_BrushForBox(&identitymatrix, boxstartmins, boxstartmaxs, 0, 0, NULL);
-               thisbrush_end = Collision_BrushForBox(&identitymatrix, boxendmins, boxendmaxs, 0, 0, NULL);
-               if (model->brush.submodel)
-               {
-                       for (i = 0, brush = model->brush.data_brushes + model->firstmodelbrush;i < model->nummodelbrushes;i++, brush++)
-                               if (brush->colbrushf)
-                                       Collision_TraceBrushBrushFloat(trace, thisbrush_start, thisbrush_end, brush->colbrushf, brush->colbrushf);
-                       if (mod_q3bsp_curves_collisions.integer)
-                               for (i = 0, surface = model->data_surfaces + model->firstmodelsurface;i < model->nummodelsurfaces;i++, surface++)
-                                       if (surface->num_collisiontriangles)
-                                               Collision_TraceBrushTriangleMeshFloat(trace, thisbrush_start, thisbrush_end, surface->num_collisiontriangles, surface->data_collisionelement3i, surface->data_collisionvertex3f, surface->num_collisionbboxstride, surface->data_collisionbbox6f, surface->texture->supercontents, surface->texture->surfaceflags, surface->texture, segmentmins, segmentmaxs);
-               }
-               else
-                       Mod_Q3BSP_TraceBrush_RecursiveBSPNode(trace, model, model->brush.data_nodes, thisbrush_start, thisbrush_end, ++markframe, segmentmins, segmentmaxs);
-       }
+               Mod_Q3BSP_TraceBrush_RecursiveBSPNode(trace, model, model->brush.data_nodes, start, end, ++markframe, segmentmins, segmentmaxs);
 }
 
 static int Mod_Q3BSP_PointSuperContents(struct model_s *model, int frame, const vec3_t point)
@@ -5805,8 +6681,14 @@ 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)
+       {
+               trace_t trace;
+               Mod_Q3BSP_TracePoint(model, NULL, NULL, &trace, point, 0);
+               supercontents = trace.startsupercontents;
+       }
        // 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++)
@@ -5832,6 +6714,141 @@ static int Mod_Q3BSP_PointSuperContents(struct model_s *model, int frame, const
        return supercontents;
 }
 
+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(dp_model_t *model, int nativecontents)
 {
        int supercontents = 0;
@@ -5907,10 +6924,9 @@ void Mod_Q3BSP_RecursiveFindNumLeafs(mnode_t *node)
 
 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";
 
@@ -5928,8 +6944,11 @@ 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->brush.TraceLineOfSight = Mod_Q3BSP_TraceLineOfSight;
        mod->brush.SuperContentsFromNativeContents = Mod_Q3BSP_SuperContentsFromNativeContents;
        mod->brush.NativeContentsFromSuperContents = Mod_Q3BSP_NativeContentsFromSuperContents;
        mod->brush.GetPVS = Mod_Q1BSP_GetPVS;
@@ -5946,7 +6965,9 @@ 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;
@@ -6017,31 +7038,622 @@ void Mod_Q3BSP_Load(dp_model_t *mod, void *buffer, void *bufferend)
        Mod_Q3BSP_LoadPVS(&header->lumps[Q3LUMP_PVS]);
        loadmodel->brush.numsubmodels = loadmodel->brushq3.num_models;
 
-       // the MakePortals code works fine on the q3bsp data as well
-       Mod_Q1BSP_MakePortals();
+       // the MakePortals code works fine on the q3bsp data as well
+       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
+       Mod_Q1BSP_CreateShadowMesh(loadmodel);
+
+       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++)
+       {
+               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 = mod->brushq3.data_models[i].firstface;
+               mod->nummodelsurfaces = mod->brushq3.data_models[i].numfaces;
+               mod->firstmodelbrush = mod->brushq3.data_models[i].firstbrush;
+               mod->nummodelbrushes = mod->brushq3.data_models[i].numbrushes;
+               mod->sortedmodelsurfaces = (int *)Mem_Alloc(loadmodel->mempool, mod->nummodelsurfaces * sizeof(*mod->sortedmodelsurfaces));
+               Mod_MakeSortedSurfaces(mod);
+
+               VectorCopy(mod->brushq3.data_models[i].mins, mod->normalmins);
+               VectorCopy(mod->brushq3.data_models[i].maxs, mod->normalmaxs);
+               // enlarge the bounding box to enclose all geometry of this model,
+               // because q3map2 sometimes lies (mostly to affect the lightgrid),
+               // which can in turn mess up the farclip (as well as culling when
+               // outside the level - an unimportant concern)
+
+               //printf("Editing model %d... BEFORE re-bounding: %f %f %f - %f %f %f\n", i, mod->normalmins[0], mod->normalmins[1], mod->normalmins[2], mod->normalmaxs[0], mod->normalmaxs[1], mod->normalmaxs[2]);
+               for (j = 0;j < mod->nummodelsurfaces;j++)
+               {
+                       const msurface_t *surface = mod->data_surfaces + j + mod->firstmodelsurface;
+                       const float *v = mod->surfmesh.data_vertex3f + 3 * surface->num_firstvertex;
+                       int k;
+                       if (!surface->num_vertices)
+                               continue;
+                       for (k = 0;k < surface->num_vertices;k++, v += 3)
+                       {
+                               mod->normalmins[0] = min(mod->normalmins[0], v[0]);
+                               mod->normalmins[1] = min(mod->normalmins[1], v[1]);
+                               mod->normalmins[2] = min(mod->normalmins[2], v[2]);
+                               mod->normalmaxs[0] = max(mod->normalmaxs[0], v[0]);
+                               mod->normalmaxs[1] = max(mod->normalmaxs[1], v[1]);
+                               mod->normalmaxs[2] = max(mod->normalmaxs[2], v[2]);
+                       }
+               }
+               //printf("Editing model %d... AFTER re-bounding: %f %f %f - %f %f %f\n", i, mod->normalmins[0], mod->normalmins[1], mod->normalmins[2], mod->normalmaxs[0], mod->normalmaxs[1], mod->normalmaxs[2]);
+               corner[0] = max(fabs(mod->normalmins[0]), fabs(mod->normalmaxs[0]));
+               corner[1] = max(fabs(mod->normalmins[1]), fabs(mod->normalmaxs[1]));
+               corner[2] = max(fabs(mod->normalmins[2]), fabs(mod->normalmaxs[2]));
+               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;
+
+               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();
+       }
+
+       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)
+{
+       int i = LittleLong(((int *)buffer)[1]);
+       if (i == Q3BSPVERSION || i == Q3BSPVERSION_IG || i == Q3BSPVERSION_LIVE)
+               Mod_Q3BSP_Load(mod,buffer, bufferend);
+       else if (i == Q2BSPVERSION)
+               Mod_Q2BSP_Load(mod,buffer, bufferend);
+       else
+               Host_Error("Mod_IBSP_Load: unknown/unsupported version %i", i);
+}
+
+void Mod_MAP_Load(dp_model_t *mod, void *buffer, void *bufferend)
+{
+       Host_Error("Mod_MAP_Load: not yet implemented");
+}
+
+#define OBJASMODEL
+
+#ifdef OBJASMODEL
+typedef struct objvertex_s
+{
+       int nextindex;
+       int submodelindex;
+       int textureindex;
+       float v[3];
+       float vt[2];
+       float vn[3];
+}
+objvertex_t;
+
+static unsigned char nobsp_pvs[1] = {1};
+
+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 *v = NULL;
+       float *vt = NULL;
+       float *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 *surface;
+       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->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->CompileShadowVolume = R_Q1BSP_CompileShadowVolume;
+       loadmodel->DrawShadowVolume = R_Q1BSP_DrawShadowVolume;
+       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);
+
+       // 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);
+                               v = (float *)Mem_Realloc(tempmempool, v, maxv * sizeof(float[3]));
+                       }
+                       v[numv*3+0] = atof(argv[1]);
+                       v[numv*3+2] = atof(argv[2]);
+                       v[numv*3+1] = atof(argv[3]);
+                       numv++;
+               }
+               else if (!strcmp(argv[0], "vt"))
+               {
+                       if (maxvt <= numvt)
+                       {
+                               maxvt = max(maxvt * 2, 1024);
+                               vt = (float *)Mem_Realloc(tempmempool, vt, maxvt * sizeof(float[2]));
+                       }
+                       vt[numvt*2+0] = atof(argv[1]);
+                       vt[numvt*2+1] = 1-atof(argv[2]);
+                       numvt++;
+               }
+               else if (!strcmp(argv[0], "vn"))
+               {
+                       if (maxvn <= numvn)
+                       {
+                               maxvn = max(maxvn * 2, 1024);
+                               vn = (float *)Mem_Realloc(tempmempool, vn, maxvn * sizeof(float[3]));
+                       }
+                       vn[numvn*3+0] = atof(argv[1]);
+                       vn[numvn*3+2] = atof(argv[2]);
+                       vn[numvn*3+1] = 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 (v && index1 >= 0 && index1 < numv)
+                                       VectorCopy(v + 3*index1, vcurrent.v);
+                               if (vt && index2 >= 0 && index2 < numvt)
+                                       Vector2Copy(vt + 2*index2, vcurrent.vt);
+                               if (vn && index3 >= 0 && index3 < numvn)
+                                       VectorCopy(vn + 3*index3, vcurrent.vn);
+                               if (numtriangles == 0)
+                               {
+                                       VectorCopy(vcurrent.v, mins);
+                                       VectorCopy(vcurrent.v, maxs);
+                               }
+                               else
+                               {
+                                       mins[0] = min(mins[0], vcurrent.v[0]);
+                                       mins[1] = min(mins[1], vcurrent.v[1]);
+                                       mins[2] = min(mins[2], vcurrent.v[2]);
+                                       maxs[0] = max(maxs[0], vcurrent.v[0]);
+                                       maxs[1] = max(maxs[1], vcurrent.v[1]);
+                                       maxs[2] = max(maxs[2], vcurrent.v[2]);
+                               }
+                               if (j == 1)
+                                       vfirst = vcurrent;
+                               else if (j >= 3)
+                               {
+                                       if (maxtriangles <= numtriangles)
+                                       {
+                                               maxtriangles = max(maxtriangles * 2, 32768);
+                                               vertices = (objvertex_t*)Mem_Realloc(loadmodel->mempool, vertices, maxtriangles * sizeof(objvertex_t[3]));
+                                       }
+                                       vertices[numtriangles*3+0] = vfirst;
+                                       vertices[numtriangles*3+1] = vprev;
+                                       vertices[numtriangles*3+2] = 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);
+                       }
+               }
+       }
+
+       // 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));
+       surface = 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...
+                       surface->texture = (texture_t *)((size_t)textureindex);
+                       // calculate bounds as we go
+                       VectorCopy(thisvertex->v, surface->mins);
+                       VectorCopy(thisvertex->v, surface->maxs);
+                       for (;vertexindex < numtriangles*3;vertexindex++)
+                       {
+                               thisvertex = vertices + vertexindex;
+                               if (thisvertex->submodelindex != submodelindex)
+                                       continue;
+                               if (thisvertex->textureindex != textureindex)
+                                       continue;
+                               // add vertex to surface bounds
+                               surface->mins[0] = min(surface->mins[0], thisvertex->v[0]);
+                               surface->mins[1] = min(surface->mins[1], thisvertex->v[1]);
+                               surface->mins[2] = min(surface->mins[2], thisvertex->v[2]);
+                               surface->maxs[0] = max(surface->maxs[0], thisvertex->v[0]);
+                               surface->maxs[1] = max(surface->maxs[1], thisvertex->v[1]);
+                               surface->maxs[2] = max(surface->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;
+                       surface->num_vertices = surfacevertices;
+                       surface->num_triangles = surfacetriangles;
+                       surface->num_firstvertex = firstvertex;
+                       surface->num_firsttriangle = firsttriangle;
+                       firstvertex += surface->num_vertices;
+                       firsttriangle += surface->num_triangles;
+                       surface++;
+                       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_neighbor3i = (int *)data;data += numtriangles * sizeof(int[3]);
+       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(v);
+       Mem_Free(vt);
+       Mem_Free(vn);
+       Mem_Free(vertexhashtable);
+       Mem_Free(vertexhashdata);
+
+       // make a single combined shadow mesh to allow optimized shadow volume creation
+       Mod_Q1BSP_CreateShadowMesh(loadmodel);
 
-       // FIXME: shader alpha should replace r_wateralpha support in q3bsp
+       // 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.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, 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, true);
+       Mod_BuildTriangleNeighbors(loadmodel->surfmesh.data_neighbor3i, loadmodel->surfmesh.data_element3i, loadmodel->surfmesh.num_triangles);
+
+       // 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;
 
-       // 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++)
@@ -6060,7 +7672,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;
@@ -6071,23 +7682,20 @@ 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;
-               mod->nummodelsurfaces = mod->brushq3.data_models[i].numfaces;
-               mod->firstmodelbrush = mod->brushq3.data_models[i].firstbrush;
-               mod->nummodelbrushes = mod->brushq3.data_models[i].numbrushes;
-               mod->sortedmodelsurfaces = (int *)Mem_Alloc(loadmodel->mempool, mod->nummodelsurfaces * sizeof(*mod->sortedmodelsurfaces));
+               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);
 
-               VectorCopy(mod->brushq3.data_models[i].mins, mod->normalmins);
-               VectorCopy(mod->brushq3.data_models[i].maxs, mod->normalmaxs);
-               // enlarge the bounding box to enclose all geometry of this model,
-               // because q3map2 sometimes lies (mostly to affect the lightgrid),
-               // which can in turn mess up the farclip (as well as culling when
-               // outside the level - an unimportant concern)
-
-               //printf("Editing model %d... BEFORE re-bounding: %f %f %f - %f %f %f\n", i, mod->normalmins[0], mod->normalmins[1], mod->normalmins[2], mod->normalmaxs[0], mod->normalmaxs[1], mod->normalmaxs[2]);
+               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;
@@ -6095,6 +7703,12 @@ void Mod_Q3BSP_Load(dp_model_t *mod, void *buffer, void *bufferend)
                        int k;
                        if (!surface->num_vertices)
                                continue;
+                       if (!l)
+                       {
+                               l = true;
+                               VectorCopy(v, mod->normalmins);
+                               VectorCopy(v, mod->normalmaxs);
+                       }
                        for (k = 0;k < surface->num_vertices;k++, v += 3)
                        {
                                mod->normalmins[0] = min(mod->normalmins[0], v[0]);
@@ -6105,7 +7719,6 @@ void Mod_Q3BSP_Load(dp_model_t *mod, void *buffer, void *bufferend)
                                mod->normalmaxs[2] = max(mod->normalmaxs[2], v[2]);
                        }
                }
-               //printf("Editing model %d... AFTER re-bounding: %f %f %f - %f %f %f\n", i, mod->normalmins[0], mod->normalmins[1], mod->normalmins[2], mod->normalmaxs[0], mod->normalmaxs[1], mod->normalmaxs[2]);
                corner[0] = max(fabs(mod->normalmins[0]), fabs(mod->normalmaxs[0]));
                corner[1] = max(fabs(mod->normalmins[1]), fabs(mod->normalmaxs[1]));
                corner[2] = max(fabs(mod->normalmins[2]), fabs(mod->normalmaxs[2]));
@@ -6131,28 +7744,956 @@ 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, 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);
+
+       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);
 }
 
-void Mod_IBSP_Load(dp_model_t *mod, void *buffer, void *bufferend)
+
+
+
+
+
+
+
+
+
+#else // OBJASMODEL
+
+#ifdef OBJWORKS
+typedef struct objvertex_s
 {
-       int i = LittleLong(((int *)buffer)[1]);
-       if (i == Q3BSPVERSION || i == Q3BSPVERSION_IG || i == Q3BSPVERSION_LIVE)
-               Mod_Q3BSP_Load(mod,buffer, bufferend);
-       else if (i == Q2BSPVERSION)
-               Mod_Q2BSP_Load(mod,buffer, bufferend);
+       float v[3];
+       float vt[2];
+       float vn[3];
+}
+objvertex_t;
+
+typedef struct objtriangle_s
+{
+       objvertex_t vertex[3];
+       int textureindex;
+       // these fields are used only in conversion to surfaces
+       int axis;
+       int surfaceindex;
+       int surfacevertexindex[3];
+       float edgeplane[3][4];
+}
+objtriangle_t;
+
+typedef objnode_s
+{
+       struct objnode_s *children[2];
+       struct objnode_s *parent;
+       objtriangle_t *triangles;
+       float normal[3];
+       float dist;
+       float mins[3];
+       float maxs[3];
+       int numtriangles;
+}
+objnode_t;
+
+objnode_t *Mod_OBJ_BSPNodeForTriangles(objnode_t *parent, objtriangle_t *triangles, int numtriangles, const float *mins, const float *maxs, mem_expandablearray_t *nodesarray, int maxclippedtriangles, objtriangle_t *clippedfronttriangles, objtriangle_t *clippedbacktriangles)
+{
+       int i, j;
+       float normal[3];
+       float dist;
+       int score;
+       float bestnormal[3];
+       float bestdist;
+       int bestscore;
+       float mins[3];
+       float maxs[3];
+       int numfronttriangles;
+       int numbacktriangles;
+       int count_front;
+       int count_back;
+       int count_both;
+       int count_on;
+       float outfrontpoints[5][3];
+       float outbackpoints[5][3];
+       int neededfrontpoints;
+       int neededbackpoints;
+       int countonpoints;
+       objnode_t *node;
+
+       node = (objnode_t *)Mem_ExpandableArray_AllocRecord(array);
+       node->parent = parent;
+       if (numtriangles)
+       {
+               VectorCopy(triangles[0].vertex[0].v, mins);
+               VectorCopy(triangles[0].vertex[0].v, maxs);
+       }
+       else if (parent && parent->children[0] == node)
+       {
+               VectorCopy(parent->mins, mins);
+               Vectorcopy(parent->maxs, maxs);
+       }
+       else if (parent && parent->children[1] == node)
+       {
+               VectorCopy(parent->mins, mins);
+               Vectorcopy(parent->maxs, maxs);
+       }
        else
-               Host_Error("Mod_IBSP_Load: unknown/unsupported version %i", i);
+       {
+               VectorClear(mins);
+               VectorClear(maxs);
+       }
+       for (i = 0;i < numtriangles;i++)
+       {
+               for (j = 0;j < 3;j++)
+               {
+                       mins[0] = min(mins[0], triangles[i].vertex[j].v[0]);
+                       mins[1] = min(mins[1], triangles[i].vertex[j].v[1]);
+                       mins[2] = min(mins[2], triangles[i].vertex[j].v[2]);
+                       maxs[0] = max(maxs[0], triangles[i].vertex[j].v[0]);
+                       maxs[1] = max(maxs[1], triangles[i].vertex[j].v[1]);
+                       maxs[2] = max(maxs[2], triangles[i].vertex[j].v[2]);
+               }
+       }
+       VectorCopy(mins, node->mins);
+       VectorCopy(maxs, node->maxs);
+       if (numtriangles <= mod_obj_leaftriangles.integer)
+       {
+               // create a leaf
+               loadmodel->brush.num_leafs++;
+               node->triangles = triangles;
+               node->numtriangles = numtriangles;
+               return node;
+       }
+
+       // create a node
+       loadmodel->brush.num_nodes++;
+       // pick a splitting plane from the various choices available to us...
+       // early splits simply halve the interval
+       bestscore = 0;
+       VectorClear(bestnormal);
+       bestdist = 0;
+       if (numtriangles <= mod_obj_splitterlimit.integer)
+               limit = numtriangles;
+       else
+               limit = 0;
+       for (i = -3;i < limit;i++)
+       {
+               if (i < 0)
+               {
+                       // first we try 3 axial splits (kdtree-like)
+                       j = i + 3;
+                       VectorClear(normal);
+                       normal[j] = 1;
+                       dist = (mins[j] + maxs[j]) * 0.5f;
+               }
+               else
+               {
+                       // then we try each triangle plane
+                       TriangleNormal(triangles[i].vertex[0].v, triangles[i].vertex[1].v, triangles[i].vertex[2].v, normal);
+                       VectorNormalize(normal);
+                       dist = DotProduct(normal, triangles[i].vertex[0].v);
+                       // use positive axial values whenever possible
+                       if (normal[0] == -1)
+                               normal[0] = 1;
+                       if (normal[1] == -1)
+                               normal[1] = 1;
+                       if (normal[2] == -1)
+                               normal[2] = 1;
+                       // skip planes that match the current best
+                       if (VectorCompare(normal, bestnormal) && dist == bestdist)
+                               continue;
+               }
+               count_on = 0;
+               count_front = 0;
+               count_back = 0;
+               count_both = 0;
+               for (j = 0;j < numtriangles;j++)
+               {
+                       dists[0] = DotProduct(normal, triangles[j].vertex[0].v) - dist;
+                       dists[1] = DotProduct(normal, triangles[j].vertex[1].v) - dist;
+                       dists[2] = DotProduct(normal, triangles[j].vertex[2].v) - dist;
+                       if (dists[0] < -DIST_EPSILON || dists[1] < -DIST_EPSILON || dists[2] < -DIST_EPSILON)
+                       {
+                               if (dists[0] > DIST_EPSILON || dists[1] > DIST_EPSILON || dists[2] > DIST_EPSILON)
+                                       count_both++;
+                               else
+                                       count_back++;
+                       }
+                       else if (dists[0] > DIST_EPSILON || dists[1] > DIST_EPSILON || dists[2] > DIST_EPSILON)
+                               count_front++;
+                       else
+                               count_on++;
+               }
+               // score is supposed to:
+               // prefer axial splits
+               // prefer evenly dividing the input triangles
+               // prefer triangles on the plane
+               // avoid triangles crossing the plane
+               score = count_on*count_on - count_both*count_both + min(count_front, count_back)*(count_front+count_back);
+               if (normal[0] == 1 || normal[1] == 1 || normal[2] == 1)
+                       score *= 2;
+               if (i == -3 || bestscore < score)
+               {
+                       VectorCopy(normal, bestnormal);
+                       bestdist = dist;
+                       bestscore = score;
+               }
+       }
+
+       // now we have chosen an optimal split plane...
+
+       // divide triangles by the splitting plane
+       numfronttriangles = 0;
+       numbacktriangles = 0;
+       for (i = 0;i < numtriangles;i++)
+       {
+               neededfrontpoints = 0;
+               neededbackpoints = 0;
+               countonpoints = 0;
+               PolygonF_Divide(3, triangles[i].vertex[0].v, bestnormal[0], bestnormal[1], bestnormal[2], bestdist, DIST_EPSILON, 5, outfrontpoints[0], &neededfrontpoints, 5, outbackpoints[0], &neededbackpoints, &countonpoints);
+               if (countonpoints > 1)
+               {
+                       // triangle lies on plane, assign it to one child only
+                       TriangleNormal(triangles[i].vertex[0].v, triangles[i].vertex[1].v, triangles[i].vertex[2].v, normal);
+                       if (DotProduct(bestnormal, normal) >= 0)
+                       {
+                               // assign to front side child
+                               obj_fronttriangles[numfronttriangles++] = triangles[i];
+                       }
+                       else
+                       {
+                               // assign to back side child
+                               obj_backtriangles[numbacktriangles++] = triangles[i];
+                       }
+               }
+               else
+               {
+                       // convert clipped polygons to triangles
+                       for (j = 0;j < neededfrontpoints-2;j++)
+                       {
+                               obj_fronttriangles[numfronttriangles] = triangles[i];
+                               VectorCopy(outfrontpoints[0], obj_fronttriangles[numfronttriangles].vertex[0].v);
+                               VectorCopy(outfrontpoints[j+1], obj_fronttriangles[numfronttriangles].vertex[1].v);
+                               VectorCopy(outfrontpoints[j+2], obj_fronttriangles[numfronttriangles].vertex[2].v);
+                               numfronttriangles++;
+                       }
+                       for (j = 0;j < neededbackpoints-2;j++)
+                       {
+                               obj_backtriangles[numbacktriangles] = triangles[i];
+                               VectorCopy(outbackpoints[0], obj_backtriangles[numbacktriangles].vertex[0].v);
+                               VectorCopy(outbackpoints[j+1], obj_backtriangles[numbacktriangles].vertex[1].v);
+                               VectorCopy(outbackpoints[j+2], obj_backtriangles[numbacktriangles].vertex[2].v);
+                               numbacktriangles++;
+                       }
+               }
+       }
+
+       // now copy the triangles out of the big buffer
+       if (numfronttriangles)
+       {
+               fronttriangles = Mem_Alloc(loadmodel->mempool, fronttriangles * sizeof(*fronttriangles));
+               memcpy(fronttriangles, obj_fronttriangles, numfronttriangles * sizeof(*fronttriangles));
+       }
+       else
+               fronttriangles = NULL;
+       if (numbacktriangles)
+       {
+               backtriangles = Mem_Alloc(loadmodel->mempool, backtriangles * sizeof(*backtriangles));
+               memcpy(backtriangles, obj_backtriangles, numbacktriangles * sizeof(*backtriangles));
+       }
+       else
+               backtriangles = NULL;
+
+       // free the original triangles we were given
+       if (triangles)
+               Mem_Free(triangles);
+       triangles = NULL;
+       numtriangles = 0;
+
+       // now create the children...
+       node->children[0] = Mod_OBJ_BSPNodeForTriangles(node, fronttriangles, numfronttriangles, frontmins, frontmaxs, nodesarray, maxclippedtriangles, clippedfronttriangles, clippedbacktriangles);
+       node->children[1] = Mod_OBJ_BSPNodeForTriangles(node, backtriangles, numbacktriangles, backmins, backmaxs, nodesarray, maxclippedtriangles, clippedfronttriangles, clippedbacktriangles);
+       return node;
 }
 
-void Mod_MAP_Load(dp_model_t *mod, void *buffer, void *bufferend)
+void Mod_OBJ_SnapVertex(float *v)
 {
-       Host_Error("Mod_MAP_Load: not yet implemented");
+       int i;
+       float a = mod_obj_vertexprecision.value;
+       float b = 1.0f / a;
+       v[0] -= floor(v[0] * a + 0.5f) * b;
+       v[1] -= floor(v[1] * a + 0.5f) * b;
+       v[2] -= floor(v[2] * a + 0.5f) * b;
+}
+
+void Mod_OBJ_ConvertBSPNode(objnode_t *objnode, mnode_t *mnodeparent)
+{
+       if (objnode->children[0])
+       {
+               // convert to mnode_t
+               mnode_t *mnode = loadmodel->brush.data_nodes + loadmodel->brush.num_nodes++;
+               mnode->parent = mnodeparent;
+               mnode->plane = loadmodel->brush.data_planes + loadmodel->brush.num_planes++;
+               VectorCopy(objnode->normal, mnode->plane->normal);
+               mnode->plane->dist = objnode->dist;
+               PlaneClassify(mnode->plane);
+               VectorCopy(objnode->mins, mnode->mins);
+               VectorCopy(objnode->maxs, mnode->maxs);
+               // push combinedsupercontents up to the parent
+               if (mnodeparent)
+                       mnodeparent->combinedsupercontents |= mnode->combinedsupercontents;
+               mnode->children[0] = Mod_OBJ_ConvertBSPNode(objnode->children[0], mnode);
+               mnode->children[1] = Mod_OBJ_ConvertBSPNode(objnode->children[1], mnode);
+       }
+       else
+       {
+               // convert to mleaf_t
+               mleaf_t *mleaf = loadmodel->brush.data_leafs + loadmodel->brush.num_leafs++;
+               mleaf->parent = mnodeparent;
+               VectorCopy(objnode->mins, mleaf->mins);
+               VectorCopy(objnode->maxs, mleaf->maxs);
+               mleaf->clusterindex = loadmodel->brush.num_leafs - 1;
+               if (objnode->numtriangles)
+               {
+                       objtriangle_t *triangles = objnode->triangles;
+                       int numtriangles = objnode->numtriangles;
+                       texture_t *texture;
+                       float edge[3][3];
+                       float normal[3];
+                       objvertex_t vertex[3];
+                       numsurfaces = 0;
+                       maxsurfaces = numtriangles;
+                       surfaces = NULL;
+                       // calculate some more data on each triangle for surface gathering
+                       for (i = 0;i < numtriangles;i++)
+                       {
+                               triangle = triangles + i;
+                               texture = loadmodel->data_textures + triangle->textureindex;
+                               Mod_OBJ_SnapVertex(triangle->vertex[0].v);
+                               Mod_OBJ_SnapVertex(triangle->vertex[1].v);
+                               Mod_OBJ_SnapVertex(triangle->vertex[2].v);
+                               TriangleNormal(triangle->vertex[0].v, triangle->vertex[1].v, triangle->vertex[2].v, normal);
+                               axis = 0;
+                               if (fabs(normal[axis]) < fabs(normal[1]))
+                                       axis = 1;
+                               if (fabs(normal[axis]) < fabs(normal[2]))
+                                       axis = 2;
+                               VectorClear(normal);
+                               normal[axis] = 1;
+                               triangle->axis = axis;
+                               VectorSubtract(triangle->vertex[1].v, triangle->vertex[0].v, edge[0]);
+                               VectorSubtract(triangle->vertex[2].v, triangle->vertex[1].v, edge[1]);
+                               VectorSubtract(triangle->vertex[0].v, triangle->vertex[2].v, edge[2]);
+                               CrossProduct(edge[0], normal, triangle->edgeplane[0]);
+                               CrossProduct(edge[1], normal, triangle->edgeplane[1]);
+                               CrossProduct(edge[2], normal, triangle->edgeplane[2]);
+                               VectorNormalize(triangle->edgeplane[0]);
+                               VectorNormalize(triangle->edgeplane[1]);
+                               VectorNormalize(triangle->edgeplane[2]);
+                               triangle->edgeplane[0][3] = DotProduct(triangle->edgeplane[0], triangle->vertex[0].v);
+                               triangle->edgeplane[1][3] = DotProduct(triangle->edgeplane[1], triangle->vertex[1].v);
+                               triangle->edgeplane[2][3] = DotProduct(triangle->edgeplane[2], triangle->vertex[2].v);
+                               triangle->surfaceindex = 0;
+                               // add to the combined supercontents while we're here...
+                               mleaf->combinedsupercontents |= texture->supercontents;
+                       }
+                       surfaceindex = 1;
+                       for (i = 0;i < numtriangles;i++)
+                       {
+                               // skip already-assigned triangles
+                               if (triangles[i].surfaceindex)
+                                       continue;
+                               texture = loadmodel->data_textures + triangles[i].textureindex;
+                               // assign a new surface to this triangle
+                               triangles[i].surfaceindex = surfaceindex++;
+                               axis = triangles[i].axis;
+                               numvertices = 3;
+                               // find the triangle's neighbors, this can take multiple passes
+                               retry = true;
+                               while (retry)
+                               {
+                                       retry = false;
+                                       for (j = i+1;j < numtriangles;j++)
+                                       {
+                                               if (triangles[j].surfaceindex || triangles[j].axis != axis || triangles[j].texture != texture)
+                                                       continue;
+                                               triangle = triangles + j;
+                                               for (k = i;k < j;k++)
+                                               {
+                                                       if (triangles[k].surfaceindex != surfaceindex)
+                                                               continue;
+                                                       if (VectorCompare(triangles[k].vertex[0].v, triangles[j].vertex[0].v)
+                                                        || VectorCompare(triangles[k].vertex[0].v, triangles[j].vertex[1].v)
+                                                        || VectorCompare(triangles[k].vertex[0].v, triangles[j].vertex[2].v)
+                                                        || VectorCompare(triangles[k].vertex[1].v, triangles[j].vertex[0].v)
+                                                        || VectorCompare(triangles[k].vertex[1].v, triangles[j].vertex[1].v)
+                                                        || VectorCompare(triangles[k].vertex[1].v, triangles[j].vertex[2].v)
+                                                        || VectorCompare(triangles[k].vertex[2].v, triangles[j].vertex[0].v)
+                                                        || VectorCompare(triangles[k].vertex[2].v, triangles[j].vertex[1].v)
+                                                        || VectorCompare(triangles[k].vertex[2].v, triangles[j].vertex[2].v))
+                                                       {
+                                                               // shares a vertex position
+                                                               --- FIXME ---
+                                                       }
+                                               }
+                                               for (k = 0;k < numvertices;k++)
+                                                       if (!VectorCompare(vertex[k].v, triangles[j].vertex[0].v) || !VectorCompare(vertex[k].v, triangles[j].vertex[1].v) || !VectorCompare(vertex[k].v, triangles[j].vertex[2].v))
+                                                               break;
+                                               if (k == numvertices)
+                                                       break; // not a neighbor
+                                               // this triangle is a neighbor and has the same axis and texture
+                                               // check now if it overlaps in lightmap projection space
+                                               triangles[j].surfaceindex;
+                                               if (triangles[j].
+                                       }
+                               }
+                               //triangles[i].surfaceindex = surfaceindex++;
+                               for (surfaceindex = 0;surfaceindex < numsurfaces;surfaceindex++)
+                               {
+                                       if (surfaces[surfaceindex].texture != texture)
+                                               continue;
+                                       // check if any triangles already in this surface overlap in lightmap projection space
+                                       
+                                       {
+                                       }
+                                       break;
+                               }
+                       }
+                       // let the collision code simply use the surfaces
+                       mleaf->containscollisionsurfaces = mleaf->combinedsupercontents != 0;
+                       mleaf->numleafsurfaces = ?;
+                       mleaf->firstleafsurface = ?;
+               }
+               // push combinedsupercontents up to the parent
+               if (mnodeparent)
+                       mnodeparent->combinedsupercontents |= mleaf->combinedsupercontents;
+       }
+}
+#endif
+
+void Mod_OBJ_Load(dp_model_t *mod, void *buffer, void *bufferend)
+{
+#ifdef OBJWORKS
+       const char *textbase = (char *)buffer, *text = textbase;
+       char *s;
+       char *argv[512];
+       char line[1024];
+       char materialname[MAX_QPATH];
+       int j, index1, index2, index3, first, prev, index;
+       int argc;
+       int linelen;
+       int numtriangles = 0;
+       int maxtriangles = 131072;
+       objtriangle_t *triangles = Mem_Alloc(tempmempool, maxtriangles * sizeof(*triangles));
+       int linenumber = 0;
+       int maxtextures = 256, numtextures = 0, textureindex = 0;
+       int maxv = 1024, numv = 0;
+       int maxvt = 1024, numvt = 0;
+       int maxvn = 1024, numvn = 0;
+       char **texturenames;
+       float *v = Mem_Alloc(tempmempool, maxv * sizeof(float[3]));
+       float *vt = Mem_Alloc(tempmempool, maxvt * sizeof(float[2]));
+       float *vn = Mem_Alloc(tempmempool, maxvn * sizeof(float[3]));
+       objvertex_t vfirst, vprev, vcurrent;
+       float mins[3];
+       float maxs[3];
+#if 0
+       int hashindex;
+       int maxverthash = 65536, numverthash = 0;
+       int numhashindex = 65536;
+       struct objverthash_s
+       {
+               struct objverthash_s *next;
+               int s;
+               int v;
+               int vt;
+               int vn;
+       }
+       *hash, **verthash = Mem_Alloc(tempmempool, numhashindex * sizeof(*verthash)), *verthashdata = Mem_Alloc(tempmempool, maxverthash * sizeof(*verthashdata)), *oldverthashdata;
+#endif
+
+       dpsnprintf(materialname, sizeof(materialname), "%s", loadmodel->name);
+
+       loadmodel->modeldatatypestring = "OBJ";
+
+       loadmodel->type = mod_obj;
+       loadmodel->soundfromcenter = true;
+       loadmodel->TraceBox = Mod_OBJ_TraceBox;
+       loadmodel->TraceLine = Mod_OBJ_TraceLine;
+       loadmodel->TracePoint = Mod_OBJ_TracePoint;
+       loadmodel->PointSuperContents = Mod_OBJ_PointSuperContents;
+       loadmodel->brush.TraceLineOfSight = Mod_OBJ_TraceLineOfSight;
+       loadmodel->brush.SuperContentsFromNativeContents = Mod_OBJ_SuperContentsFromNativeContents;
+       loadmodel->brush.NativeContentsFromSuperContents = Mod_OBJ_NativeContentsFromSuperContents;
+       loadmodel->brush.GetPVS = Mod_OBJ_GetPVS;
+       loadmodel->brush.FatPVS = Mod_OBJ_FatPVS;
+       loadmodel->brush.BoxTouchingPVS = Mod_OBJ_BoxTouchingPVS;
+       loadmodel->brush.BoxTouchingLeafPVS = Mod_OBJ_BoxTouchingLeafPVS;
+       loadmodel->brush.BoxTouchingVisibleLeafs = Mod_OBJ_BoxTouchingVisibleLeafs;
+       loadmodel->brush.FindBoxClusters = Mod_OBJ_FindBoxClusters;
+       loadmodel->brush.LightPoint = Mod_OBJ_LightPoint;
+       loadmodel->brush.FindNonSolidLocation = Mod_OBJ_FindNonSolidLocation;
+       loadmodel->brush.AmbientSoundLevelsForPoint = NULL;
+       loadmodel->brush.RoundUpToHullSize = NULL;
+       loadmodel->brush.PointInLeaf = Mod_OBJ_PointInLeaf;
+       loadmodel->Draw = R_Q1BSP_Draw;
+       loadmodel->DrawDepth = R_Q1BSP_DrawDepth;
+       loadmodel->DrawDebug = R_Q1BSP_DrawDebug;
+       loadmodel->DrawPrepass = R_Q1BSP_DrawPrepass;
+       loadmodel->GetLightInfo = R_Q1BSP_GetLightInfo;
+       loadmodel->CompileShadowMap = R_Q1BSP_CompileShadowMap;
+       loadmodel->DrawShadowMap = R_Q1BSP_DrawShadowMap;
+       loadmodel->CompileShadowVolume = R_Q1BSP_CompileShadowVolume;
+       loadmodel->DrawShadowVolume = R_Q1BSP_DrawShadowVolume;
+       loadmodel->DrawLight = R_Q1BSP_DrawLight;
+
+       VectorClear(mins);
+       VectorClear(maxs);
+
+       // parse the OBJ text now
+       for(;;)
+       {
+               if (!*text)
+                       break;
+               linenumber++;
+               linelen = 0;
+               for (linelen = 0;text[linelen] && text[linelen] != '\r' && text[linelen] != '\n';linelen++)
+                       line[linelen] = text[linelen];
+               line[linelen] = 0;
+               for (argc = 0;argc < (int)(sizeof(argv)/sizeof(argv[0]));argc++)
+                       argv[argc] = "";
+               argc = 0;
+               s = line;
+               while (*s == ' ' || *s == '\t')
+                       s++;
+               while (*s)
+               {
+                       argv[argc++] = s;
+                       while (*s > ' ')
+                               s++;
+                       if (!*s)
+                               break;
+                       *s++ = 0;
+                       while (*s == ' ' || *s == '\t')
+                               s++;
+               }
+               if (!argc)
+                       continue;
+               if (argv[0][0] == '#')
+                       continue;
+               if (!strcmp(argv[0], "v"))
+               {
+                       if (maxv <= numv)
+                       {
+                               float *oldv = v;
+                               maxv *= 2;
+                               v = Mem_Alloc(tempmempool, maxv * sizeof(float[3]));
+                               if (oldv)
+                               {
+                                       memcpy(v, oldv, numv * sizeof(float[3]));
+                                       Mem_Free(oldv);
+                               }
+                       }
+                       v[numv*3+0] = atof(argv[1]);
+                       v[numv*3+1] = atof(argv[2]);
+                       v[numv*3+2] = atof(argv[3]);
+                       numv++;
+               }
+               else if (!strcmp(argv[0], "vt"))
+               {
+                       if (maxvt <= numvt)
+                       {
+                               float *oldvt = vt;
+                               maxvt *= 2;
+                               vt = Mem_Alloc(tempmempool, maxvt * sizeof(float[2]));
+                               if (oldvt)
+                               {
+                                       memcpy(vt, oldvt, numvt * sizeof(float[2]));
+                                       Mem_Free(oldvt);
+                               }
+                       }
+                       vt[numvt*2+0] = atof(argv[1]);
+                       vt[numvt*2+1] = atof(argv[2]);
+                       numvt++;
+               }
+               else if (!strcmp(argv[0], "vn"))
+               {
+                       if (maxvn <= numvn)
+                       {
+                               float *oldvn = vn;
+                               maxvn *= 2;
+                               vn = Mem_Alloc(tempmempool, maxvn * sizeof(float[3]));
+                               if (oldvn)
+                               {
+                                       memcpy(vn, oldvn, numvn * sizeof(float[3]));
+                                       Mem_Free(oldvn);
+                               }
+                       }
+                       vn[numvn*3+0] = atof(argv[1]);
+                       vn[numvn*3+1] = atof(argv[2]);
+                       vn[numvn*3+2] = atof(argv[3]);
+                       numvn++;
+               }
+               else if (!strcmp(argv[0], "f"))
+               {
+                       for (j = 1;j < argc;j++)
+                       {
+                               index1 = atoi(argv[j]);
+                               while(argv[j][0] && argv[j][0] != '/')
+                                       argv[j]++;
+                               if (argv[j][0])
+                                       argv[j]++;
+                               index2 = atoi(argv[j]);
+                               while(argv[j][0] && argv[j][0] != '/')
+                                       argv[j]++;
+                               if (argv[j][0])
+                                       argv[j]++;
+                               index3 = atoi(argv[j]);
+                               // negative refers to a recent vertex
+                               // zero means not specified
+                               // positive means an absolute vertex index
+                               if (index1 < 0)
+                                       index1 = numv - index1;
+                               if (index2 < 0)
+                                       index2 = numvt - index2;
+                               if (index3 < 0)
+                                       index3 = numvn - index3;
+                               VectorCopy(v + 3*index1, vcurrent.v);
+                               Vector2Copy(vt + 2*index2, vcurrent.vt);
+                               VectorCopy(vn + 3*index3, vcurrent.vn);
+                               if (numtriangles == 0)
+                               {
+                                       VectorCopy(vcurrent.v, mins);
+                                       VectorCopy(vcurrent.v, maxs);
+                               }
+                               else
+                               {
+                                       mins[0] = min(mins[0], vcurrent.v[0]);
+                                       mins[1] = min(mins[1], vcurrent.v[1]);
+                                       mins[2] = min(mins[2], vcurrent.v[2]);
+                                       maxs[0] = max(maxs[0], vcurrent.v[0]);
+                                       maxs[1] = max(maxs[1], vcurrent.v[1]);
+                                       maxs[2] = max(maxs[2], vcurrent.v[2]);
+                               }
+                               if (j == 1)
+                                       vfirst = vcurrent;
+                               else if (j >= 3)
+                               {
+                                       if (maxtriangles <= numtriangles)
+                                       {
+                                               objtriangle_t *oldtriangles = triangles;
+                                               maxtriangles *= 2;
+                                               triangles = Mem_Alloc(tempmempool, maxtriangles * sizeof(*triangles));
+                                               if (oldtriangles)
+                                               {
+                                                       memcpy(triangles, oldtriangles, maxtriangles * sizeof(*triangles));
+                                                       Mem_Free(oldtriangles);
+                                               }
+                                       }
+                                       triangles[numtriangles].textureindex = textureindex;
+                                       triangles[numtriangles].vertex[0] = vfirst;
+                                       triangles[numtriangles].vertex[1] = vprev;
+                                       triangles[numtriangles].vertex[2] = vcurrent;
+                                       numtriangles++;
+                               }
+                               vprev = vcurrent;
+                               prev = index;
+                       }
+               }
+               else if (!strcmp(argv[0], "o") || !strcmp(argv[0], "g"))
+                       ;
+               else if (!!strcmp(argv[0], "usemtl"))
+               {
+                       for (i = 0;i < numtextures;i++)
+                               if (!strcmp(texturenames[numtextures], argv[1]))
+                                       break;
+                       if (i < numtextures)
+                               texture = textures + i;
+                       else
+                       {
+                               if (maxtextures <= numtextures)
+                               {
+                                       texture_t *oldtextures = textures;
+                                       maxtextures *= 2;
+                                       textures = Mem_Alloc(tempmempool, maxtextures * sizeof(*textures));
+                                       if (oldtextures)
+                                       {
+                                               memcpy(textures, oldtextures, numtextures * sizeof(*textures));
+                                               Mem_Free(oldtextures);
+                                       }
+                               }
+                               textureindex = numtextures++;
+                               texturenames[textureindex] = Mem_Alloc(tempmempool, strlen(argv[1]) + 1);
+                               memcpy(texturenames[textureindex], argv[1], strlen(argv[1]) + 1);
+                       }
+               }
+               text += linelen;
+               if (*text == '\r')
+                       text++;
+               if (*text == '\n')
+                       text++;
+       }
+
+       // now that we have the OBJ data loaded as-is, we can convert it
+
+       // load the textures
+       loadmodel->num_textures = numtextures;
+       loadmodel->data_textures = Mem_Alloc(loadmodel->mempool, loadmodel->num_textures * sizeof(texture_t));
+       for (i = 0;i < numtextures;i++)
+               Mod_LoadTextureFromQ3Shader(loadmodel->data_textures + i, texturenames[i], true, true, TEXF_MIPMAP | TEXF_ALPHA | TEXF_ISWORLD | TEXF_PICMIP | TEXF_COMPRESS);
+
+       // free the texturenames array since we are now done with it
+       for (i = 0;i < numtextures;i++)
+       {
+               Mem_Free(texturenames[i]);
+               texturenames[i] = NULL;
+       }
+       Mem_Free(texturenames);
+       texturenames = NULL;
+
+       // copy the model bounds, then enlarge the yaw and rotated bounds according to radius
+       VectorCopy(mins, loadmodel->normalmins);
+       VectorCopy(maxs, loadmodel->normalmaxs);
+       dist = max(fabs(loadmodel->normalmins[0]), fabs(loadmodel->normalmaxs[0]));
+       modelyawradius = max(fabs(loadmodel->normalmins[1]), fabs(loadmodel->normalmaxs[1]));
+       modelyawradius = dist*dist+modelyawradius*modelyawradius;
+       modelradius = max(fabs(loadmodel->normalmins[2]), fabs(loadmodel->normalmaxs[2]));
+       modelradius = modelyawradius + modelradius * modelradius;
+       modelyawradius = sqrt(modelyawradius);
+       modelradius = sqrt(modelradius);
+       loadmodel->yawmins[0] = loadmodel->yawmins[1] = -modelyawradius;
+       loadmodel->yawmins[2] = loadmodel->normalmins[2];
+       loadmodel->yawmaxs[0] = loadmodel->yawmaxs[1] =  modelyawradius;
+       loadmodel->yawmaxs[2] = loadmodel->normalmaxs[2];
+       loadmodel->rotatedmins[0] = loadmodel->rotatedmins[1] = loadmodel->rotatedmins[2] = -modelradius;
+       loadmodel->rotatedmaxs[0] = loadmodel->rotatedmaxs[1] = loadmodel->rotatedmaxs[2] =  modelradius;
+       loadmodel->radius = modelradius;
+       loadmodel->radius2 = modelradius * modelradius;
+
+       // make sure the temp triangle buffer is big enough for BSP building
+       maxclippedtriangles = numtriangles*4;
+       if (numtriangles > 0)
+       {
+               clippedfronttriangles = Mem_Alloc(loadmodel->mempool, maxclippedtriangles * 2 * sizeof(objtriangle_t));
+               clippedbacktriangles = clippedfronttriangles + maxclippedtriangles;
+       }
+
+       // generate a rough BSP tree from triangle data, we don't have to be too careful here, it only has to define the basic areas of the map
+       loadmodel->brush.num_leafs = 0;
+       loadmodel->brush.num_nodes = 0;
+       Mem_ExpandableArray_NewArray(&nodesarray, loadmodel->mempool, sizeof(objnode_t), 1024);
+       rootnode = Mod_OBJ_BSPNodeForTriangles(triangles, numtriangles, mins, maxs, &nodesarray, maxclippedtriangles, clippedfronttriangles, clippedbacktriangles);
+
+       // convert the BSP tree to mnode_t and mleaf_t structures and convert the triangles to msurface_t...
+       loadmodel->brush.data_leafs = Mem_Alloc(loadmodel->mempool, loadmodel->brush.num_leafs * sizeof(mleaf_t));
+       loadmodel->brush.data_nodes = Mem_Alloc(loadmodel->mempool, loadmodel->brush.num_nodes * sizeof(mnode_t));
+       loadmodel->brush.data_planes = Mem_Alloc(loadmodel->mempool, loadmodel->brush.num_nodes * sizeof(mplane_t));
+       loadmodel->brush.num_leafs = 0;
+       loadmodel->brush.num_nodes = 0;
+       loadmodel->brush.num_planes = 0;
+       Mod_OBJ_ConvertAndFreeBSPNode(rootnode);
+
+       if (clippedfronttriangles)
+               Mem_Free(clippedfronttriangles);
+       maxclippedtriangles = 0;
+       clippedfronttriangles = NULL;
+       clippedbacktriangles = NULL;
+
+--- NOTHING DONE PAST THIS POINT ---
+
+       loadmodel->numskins = LittleLong(pinmodel->num_skins);
+       numxyz = LittleLong(pinmodel->num_xyz);
+       numst = LittleLong(pinmodel->num_st);
+       loadmodel->surfmesh.num_triangles = LittleLong(pinmodel->num_tris);
+       loadmodel->numframes = LittleLong(pinmodel->num_frames);
+       loadmodel->surfmesh.num_morphframes = loadmodel->numframes;
+       loadmodel->num_poses = loadmodel->surfmesh.num_morphframes;
+       skinwidth = LittleLong(pinmodel->skinwidth);
+       skinheight = LittleLong(pinmodel->skinheight);
+       iskinwidth = 1.0f / skinwidth;
+       iskinheight = 1.0f / skinheight;
+
+       loadmodel->num_surfaces = 1;
+       loadmodel->nummodelsurfaces = loadmodel->num_surfaces;
+       data = (unsigned char *)Mem_Alloc(loadmodel->mempool, loadmodel->num_surfaces * sizeof(msurface_t) + loadmodel->num_surfaces * sizeof(int) + loadmodel->numframes * sizeof(animscene_t) + loadmodel->numframes * sizeof(float[6]) + loadmodel->surfmesh.num_triangles * sizeof(int[3]) + loadmodel->surfmesh.num_triangles * sizeof(int[3]));
+       loadmodel->data_surfaces = (msurface_t *)data;data += loadmodel->num_surfaces * sizeof(msurface_t);
+       loadmodel->sortedmodelsurfaces = (int *)data;data += loadmodel->num_surfaces * sizeof(int);
+       loadmodel->sortedmodelsurfaces[0] = 0;
+       loadmodel->animscenes = (animscene_t *)data;data += loadmodel->numframes * sizeof(animscene_t);
+       loadmodel->surfmesh.data_morphmd2framesize6f = (float *)data;data += loadmodel->numframes * sizeof(float[6]);
+       loadmodel->surfmesh.data_element3i = (int *)data;data += loadmodel->surfmesh.num_triangles * sizeof(int[3]);
+       loadmodel->surfmesh.data_neighbor3i = (int *)data;data += loadmodel->surfmesh.num_triangles * sizeof(int[3]);
+
+       loadmodel->synctype = ST_RAND;
+
+       // load the skins
+       inskin = (char *)(base + LittleLong(pinmodel->ofs_skins));
+       skinfiles = Mod_LoadSkinFiles();
+       if (skinfiles)
+       {
+               loadmodel->num_textures = loadmodel->num_surfaces * loadmodel->numskins;
+               loadmodel->num_texturesperskin = loadmodel->num_surfaces;
+               loadmodel->data_textures = (texture_t *)Mem_Alloc(loadmodel->mempool, loadmodel->num_surfaces * loadmodel->numskins * sizeof(texture_t));
+               Mod_BuildAliasSkinsFromSkinFiles(loadmodel->data_textures, skinfiles, "default", "");
+               Mod_FreeSkinFiles(skinfiles);
+       }
+       else if (loadmodel->numskins)
+       {
+               // skins found (most likely not a player model)
+               loadmodel->num_textures = loadmodel->num_surfaces * loadmodel->numskins;
+               loadmodel->num_texturesperskin = loadmodel->num_surfaces;
+               loadmodel->data_textures = (texture_t *)Mem_Alloc(loadmodel->mempool, loadmodel->num_surfaces * loadmodel->numskins * sizeof(texture_t));
+               for (i = 0;i < loadmodel->numskins;i++, inskin += MD2_SKINNAME)
+                       Mod_LoadTextureFromQ3Shader(loadmodel->data_textures + i * loadmodel->num_surfaces, inskin, true, true, (r_mipskins.integer ? TEXF_MIPMAP : 0) | TEXF_ALPHA | TEXF_PICMIP | TEXF_COMPRESS);
+       }
+       else
+       {
+               // no skins (most likely a player model)
+               loadmodel->numskins = 1;
+               loadmodel->num_textures = loadmodel->num_surfaces * loadmodel->numskins;
+               loadmodel->num_texturesperskin = loadmodel->num_surfaces;
+               loadmodel->data_textures = (texture_t *)Mem_Alloc(loadmodel->mempool, loadmodel->num_surfaces * loadmodel->numskins * sizeof(texture_t));
+               Mod_BuildAliasSkinFromSkinFrame(loadmodel->data_textures, NULL);
+       }
+
+       loadmodel->skinscenes = (animscene_t *)Mem_Alloc(loadmodel->mempool, sizeof(animscene_t) * loadmodel->numskins);
+       for (i = 0;i < loadmodel->numskins;i++)
+       {
+               loadmodel->skinscenes[i].firstframe = i;
+               loadmodel->skinscenes[i].framecount = 1;
+               loadmodel->skinscenes[i].loop = true;
+               loadmodel->skinscenes[i].framerate = 10;
+       }
+
+       // load the triangles and stvert data
+       inst = (unsigned short *)(base + LittleLong(pinmodel->ofs_st));
+       intri = (md2triangle_t *)(base + LittleLong(pinmodel->ofs_tris));
+       md2verthash = (struct md2verthash_s **)Mem_Alloc(tempmempool, 65536 * sizeof(hash));
+       md2verthashdata = (struct md2verthash_s *)Mem_Alloc(tempmempool, loadmodel->surfmesh.num_triangles * 3 * sizeof(*hash));
+       // swap the triangle list
+       loadmodel->surfmesh.num_vertices = 0;
+       for (i = 0;i < loadmodel->surfmesh.num_triangles;i++)
+       {
+               for (j = 0;j < 3;j++)
+               {
+                       xyz = (unsigned short) LittleShort (intri[i].index_xyz[j]);
+                       st = (unsigned short) LittleShort (intri[i].index_st[j]);
+                       if (xyz >= numxyz)
+                       {
+                               Con_Printf("%s has an invalid xyz index (%i) on triangle %i, resetting to 0\n", loadmodel->name, xyz, i);
+                               xyz = 0;
+                       }
+                       if (st >= numst)
+                       {
+                               Con_Printf("%s has an invalid st index (%i) on triangle %i, resetting to 0\n", loadmodel->name, st, i);
+                               st = 0;
+                       }
+                       hashindex = (xyz * 256 + st) & 65535;
+                       for (hash = md2verthash[hashindex];hash;hash = hash->next)
+                               if (hash->xyz == xyz && hash->st == st)
+                                       break;
+                       if (hash == NULL)
+                       {
+                               hash = md2verthashdata + loadmodel->surfmesh.num_vertices++;
+                               hash->xyz = xyz;
+                               hash->st = st;
+                               hash->next = md2verthash[hashindex];
+                               md2verthash[hashindex] = hash;
+                       }
+                       loadmodel->surfmesh.data_element3i[i*3+j] = (hash - md2verthashdata);
+               }
+       }
+
+       vertremap = (int *)Mem_Alloc(loadmodel->mempool, loadmodel->surfmesh.num_vertices * sizeof(int));
+       data = (unsigned char *)Mem_Alloc(loadmodel->mempool, loadmodel->surfmesh.num_vertices * sizeof(float[2]) + loadmodel->surfmesh.num_vertices * loadmodel->surfmesh.num_morphframes * sizeof(trivertx_t));
+       loadmodel->surfmesh.data_texcoordtexture2f = (float *)data;data += loadmodel->surfmesh.num_vertices * sizeof(float[2]);
+       loadmodel->surfmesh.data_morphmdlvertex = (trivertx_t *)data;data += loadmodel->surfmesh.num_vertices * loadmodel->surfmesh.num_morphframes * sizeof(trivertx_t);
+       for (i = 0;i < loadmodel->surfmesh.num_vertices;i++)
+       {
+               int sts, stt;
+               hash = md2verthashdata + i;
+               vertremap[i] = hash->xyz;
+               sts = LittleShort(inst[hash->st*2+0]);
+               stt = LittleShort(inst[hash->st*2+1]);
+               if (sts < 0 || sts >= skinwidth || stt < 0 || stt >= skinheight)
+               {
+                       Con_Printf("%s has an invalid skin coordinate (%i %i) on vert %i, changing to 0 0\n", loadmodel->name, sts, stt, i);
+                       sts = 0;
+                       stt = 0;
+               }
+               loadmodel->surfmesh.data_texcoordtexture2f[i*2+0] = sts * iskinwidth;
+               loadmodel->surfmesh.data_texcoordtexture2f[i*2+1] = stt * iskinheight;
+       }
+
+       Mem_Free(md2verthash);
+       Mem_Free(md2verthashdata);
+
+       // generate ushort elements array if possible
+       if (loadmodel->surfmesh.num_vertices <= 65536)
+               loadmodel->surfmesh.data_element3s = (unsigned short *)Mem_Alloc(loadmodel->mempool, sizeof(unsigned short[3]) * loadmodel->surfmesh.num_triangles);
+
+       // load the frames
+       datapointer = (base + LittleLong(pinmodel->ofs_frames));
+       for (i = 0;i < loadmodel->surfmesh.num_morphframes;i++)
+       {
+               int k;
+               trivertx_t *v;
+               trivertx_t *out;
+               pinframe = (md2frame_t *)datapointer;
+               datapointer += sizeof(md2frame_t);
+               // store the frame scale/translate into the appropriate array
+               for (j = 0;j < 3;j++)
+               {
+                       loadmodel->surfmesh.data_morphmd2framesize6f[i*6+j] = LittleFloat(pinframe->scale[j]);
+                       loadmodel->surfmesh.data_morphmd2framesize6f[i*6+3+j] = LittleFloat(pinframe->translate[j]);
+               }
+               // convert the vertices
+               v = (trivertx_t *)datapointer;
+               out = loadmodel->surfmesh.data_morphmdlvertex + i * loadmodel->surfmesh.num_vertices;
+               for (k = 0;k < loadmodel->surfmesh.num_vertices;k++)
+                       out[k] = v[vertremap[k]];
+               datapointer += numxyz * sizeof(trivertx_t);
+
+               strlcpy(loadmodel->animscenes[i].name, pinframe->name, sizeof(loadmodel->animscenes[i].name));
+               loadmodel->animscenes[i].firstframe = i;
+               loadmodel->animscenes[i].framecount = 1;
+               loadmodel->animscenes[i].framerate = 10;
+               loadmodel->animscenes[i].loop = true;
+       }
+
+       Mem_Free(vertremap);
+
+       Mod_MakeSortedSurfaces(loadmodel);
+       Mod_BuildTriangleNeighbors(loadmodel->surfmesh.data_neighbor3i, loadmodel->surfmesh.data_element3i, loadmodel->surfmesh.num_triangles);
+       Mod_Alias_CalculateBoundingBox();
+       Mod_Alias_MorphMesh_CompileFrames();
+
+       surface = loadmodel->data_surfaces;
+       surface->texture = loadmodel->data_textures;
+       surface->num_firsttriangle = 0;
+       surface->num_triangles = loadmodel->surfmesh.num_triangles;
+       surface->num_firstvertex = 0;
+       surface->num_vertices = loadmodel->surfmesh.num_vertices;
+
+       loadmodel->surfmesh.isanimated = false;
+
+       if (loadmodel->surfmesh.data_element3s)
+               for (i = 0;i < loadmodel->surfmesh.num_triangles*3;i++)
+                       loadmodel->surfmesh.data_element3s[i] = loadmodel->surfmesh.data_element3i[i];
+#endif
 }
+#endif // !OBJASMODEL
 
 qboolean Mod_CanSeeBox_Trace(int numsamples, float t, dp_model_t *model, vec3_t eye, vec3_t minsX, vec3_t maxsX)
 {