author divverent Sat, 14 Mar 2009 18:31:04 +0000 (18:31 +0000) committer divverent Sat, 14 Mar 2009 18:31:04 +0000 (18:31 +0000)
Also adds a mode for flat patch sides (so they no longer get tesselated at all).

http://www.alientrap.org/forum/viewtopic.php?t=4200

The submitted patch cleaned up a little, but it's probably not perfect yet.

git-svn-id: svn://svn.icculus.org/twilight/trunk/darkplaces@8808 d7cf8633-e32d-0410-b094-e92efae38249

 curves.c patch | blob | history curves.h patch | blob | history model_brush.c patch | blob | history

index 3a9e22a..e4ef52c 100644 (file)
--- a/curves.c
+++ b/curves.c
@@ -40,17 +40,35 @@ double bsplinesample(int dimensions, double t, double *param)
*/

#include "quakedef.h"
+#include "mathlib.h"

#include <math.h>
#include "curves.h"

+// Calculate number of resulting vertex rows/columns by given patch size and tesselation factor
+// tess=0 means that we reduce detalization of base 3x3 patches by removing middle row and column of vertices
+// "DimForTess" is "DIMension FOR TESSelation factor"
+// NB: tess=0 actually means that tess must be 0.5, but obviously it can't because it is of int type. (so "a*tess"-like code is replaced by "a/2" if tess=0)
+int Q3PatchDimForTess(int size, int tess)
+{
+       if (tess > 0)
+               return (size - 1) * tess + 1;
+       else if (tess == 0)
+               return (size - 1) / 2 + 1;
+       else
+               return 0; // Maybe warn about wrong tess here?
+}
+
// usage:
// to expand a 5x5 patch to 21x21 vertices (4x4 tesselation), one might use this call:
// Q3PatchSubdivideFloat(3, sizeof(float), outvertices, 5, 5, sizeof(float), patchvertices, 4, 4);
void Q3PatchTesselateFloat(int numcomponents, int outputstride, float *outputvertices, int patchwidth, int patchheight, int inputstride, float *patchvertices, int tesselationwidth, int tesselationheight)
{
-       int k, l, x, y, component, outputwidth = (patchwidth-1)*tesselationwidth+1;
+       int k, l, x, y, component, outputwidth = Q3PatchDimForTess(patchwidth, tesselationwidth);
float px, py, *v, a, b, c, *cp, temp;
+       int xmax = max(1, 2*tesselationwidth);
+       int ymax = max(1, 2*tesselationheight);
+
// iterate over the individual 3x3 quadratic spline surfaces one at a time
// expanding them to fill the output array (with some overlap to ensure
// the edges are filled)
@@ -63,11 +81,11 @@ void Q3PatchTesselateFloat(int numcomponents, int outputstride, float *outputver
for (x = 0;x < 3;x++)
cp[y][x] = (float *)((unsigned char *)patchvertices + ((k+y)*patchwidth+(l+x)) * inputstride);
// for each row...
-                       for (y = 0;y <= tesselationheight*2;y++)
+                       for (y = 0;y <= ymax;y++)
{
// calculate control points for this row by collapsing the 3
// rows of control points to one row using py
-                               py = (float)y / (float)(tesselationheight*2);
+                               py = (float)y / (float)ymax;
// calculate quadratic spline weights for py
a = ((1.0f - py) * (1.0f - py));
b = ((1.0f - py) * (2.0f * py));
@@ -79,12 +97,12 @@ void Q3PatchTesselateFloat(int numcomponents, int outputstride, float *outputver
temp[component] = cp[component] * a + cp[component] * b + cp[component] * c;
}
// fetch a pointer to the beginning of the output vertex row
-                               v = (float *)((unsigned char *)outputvertices + ((k * tesselationheight + y) * outputwidth + l * tesselationwidth) * outputstride);
+                               v = (float *)((unsigned char *)outputvertices + ((k * ymax / 2 + y) * outputwidth + l * xmax / 2) * outputstride);
// for each column of the row...
-                               for (x = 0;x <= (tesselationwidth*2);x++)
+                               for (x = 0;x <= xmax;x++)
{
// calculate point based on the row control points
-                                       px = (float)x / (float)(tesselationwidth*2);
+                                       px = (float)x / (float)xmax;
// calculate quadratic spline weights for px
// (could be precalculated)
a = ((1.0f - px) * (1.0f - px));
@@ -118,6 +136,25 @@ void Q3PatchTesselateFloat(int numcomponents, int outputstride, float *outputver
#endif
}

+static int Q3PatchTesselation(float bestsquareddeviation, float tolerance)
+{
+       float f;
+       f = sqrt(bestsquareddeviation) / tolerance;
+       //if(f < 0.25) // REALLY flat patches
+       if(f < 0.0001) // TOTALLY flat patches
+               return 0;
+       else if(f < 2)
+               return 1;
+       else
+               return (int) floor(log(f) / log(2)) + 1;
+               // this is always at least 2
+               // maps [0.25..0.5[ to -1 (actually, 1 is returned)
+               // maps [0.5..1[ to 0 (actually, 1 is returned)
+               // maps [1..2[ to 1
+               // maps [2..4[ to 2
+               // maps [4..8[ to 4
+}
+
// returns how much tesselation of each segment is needed to remain under tolerance
int Q3PatchTesselationOnX(int patchwidth, int patchheight, int components, const float *in, float tolerance)
{
@@ -139,7 +176,7 @@ int Q3PatchTesselationOnX(int patchwidth, int patchheight, int components, const
bestsquareddeviation = squareddeviation;
}
}
-       return (int)floor(log(sqrt(bestsquareddeviation) / tolerance) / log(2)) + 1;
+       return Q3PatchTesselation(bestsquareddeviation, tolerance);
}

// returns how much tesselation of each segment is needed to remain under tolerance
@@ -163,13 +200,137 @@ int Q3PatchTesselationOnY(int patchwidth, int patchheight, int components, const
bestsquareddeviation = squareddeviation;
}
}
-       return (int)floor(log(sqrt(bestsquareddeviation) / tolerance) / log(2)) + 1;
+       return Q3PatchTesselation(bestsquareddeviation, tolerance);
}

+// Find an equal vertex in array. Check only vertices with odd X and Y
+static int FindEqualOddVertexInArray(int numcomponents, float *vertex, float *vertices, int width, int height)
+{
+       int x, y, j;
+       for (y=0; y<height; y+=2)
+       {
+               for (x=0; x<width; x+=2)
+               {
+                       qboolean found = true;
+                       for (j=0; j<numcomponents; j++)
+                               if (fabs(*(vertex+j) - *(vertices+j)) > 0.05)
+                               // div0: this is notably smaller than the smallest radiant grid
+                               // but large enough so we don't need to get scared of roundoff
+                               // errors
+                               {
+                                       found = false;
+                                       break;
+                               }
+                       if(found)
+                               return y*width+x;
+                       vertices += numcomponents*2;
+               }
+               vertices += numcomponents*(width-1);
+       }
+       return -1;
+}
+
+#define SIDE_INVALID -1
+#define SIDE_X 0
+#define SIDE_Y 1
+
+static int GetSide(int p1, int p2, int width, int height, int *pointdist)
+{
+       int x1 = p1 % width, y1 = p1 / width;
+       int x2 = p2 % width, y2 = p2 / width;
+       if (p1 < 0 || p2 < 0)
+               return SIDE_INVALID;
+       if (x1 == x2)
+       {
+               if (y1 != y2)
+               {
+                       *pointdist = abs(y2 - y1);
+                       return SIDE_Y;
+               }
+               else
+                       return SIDE_INVALID;
+       }
+       else if (y1 == y2)
+       {
+               *pointdist = abs(x2 - x1);
+               return SIDE_X;
+       }
+       else
+               return SIDE_INVALID;
+}
+
+// Increase tesselation of one of two touching patches to make a seamless connection between them
+// Returns 0 in case if patches were not modified, otherwise 1
+int Q3PatchAdjustTesselation(int numcomponents, patchinfo_t *patch1, float *patchvertices1, patchinfo_t *patch2, float *patchvertices2)
+{
+       // what we are doing here is:
+       //   we take for each corner of one patch
+       //   and check if the other patch contains that corner
+       //   once we have a pair of such matches
+
+       struct {int id1,id2;} commonverts;
+       int i, j, k, side1, side2, *tess1, *tess2;
+       int dist1, dist2;
+       qboolean modified = false;
+
+       // Potential paired vertices (corners of the first patch)
+       commonverts.id1 = 0;
+       commonverts.id1 = patch1->xsize-1;
+       commonverts.id1 = patch1->xsize*(patch1->ysize-1);
+       commonverts.id1 = patch1->xsize*patch1->ysize-1;
+       for (i=0;i<4;++i)
+               commonverts[i].id2 = FindEqualOddVertexInArray(numcomponents, patchvertices1+numcomponents*commonverts[i].id1, patchvertices2, patch2->xsize, patch2->ysize);
+
+       // Corners of the second patch
+       commonverts.id2 = 0;
+       commonverts.id2 = patch2->xsize-1;
+       commonverts.id2 = patch2->xsize*(patch2->ysize-1);
+       commonverts.id2 = patch2->xsize*patch2->ysize-1;
+       for (i=4;i<8;++i)
+               commonverts[i].id1 = FindEqualOddVertexInArray(numcomponents, patchvertices2+numcomponents*commonverts[i].id2, patchvertices1, patch1->xsize, patch1->ysize);
+
+       for (i=0;i<8;++i)
+               for (j=i+1;j<8;++j)
+               {
+                       side1 = GetSide(commonverts[i].id1,commonverts[j].id1,patch1->xsize,patch1->ysize,&dist1);
+                       side2 = GetSide(commonverts[i].id2,commonverts[j].id2,patch2->xsize,patch2->ysize,&dist2);
+
+                       if (side1 == SIDE_INVALID || side2 == SIDE_INVALID)
+                               continue;
+
+                       if(dist1 != dist2)
+                       {
+                               // no patch welding if the resolutions mismatch
+                               continue;
+                       }
+
+                       // Update every lod level
+                       for (k=0;k<PATCH_LODS_NUM;++k)
+                       {
+                               tess1 = side1 == SIDE_X ? &patch1->lods[k].xtess : &patch1->lods[k].ytess;
+                               tess2 = side2 == SIDE_X ? &patch2->lods[k].xtess : &patch2->lods[k].ytess;
+                               if (*tess1 != *tess2)
+                               {
+                                       if (*tess1 < *tess2)
+                                               *tess1 = *tess2;
+                                       else
+                                               *tess2 = *tess1;
+                                       modified = true;
+                               }
+                       }
+               }
+
+       return modified;
+}
+
+#undef SIDE_INVALID
+#undef SIDE_X
+#undef SIDE_Y
+
// calculates elements for a grid of vertices
// (such as those produced by Q3PatchTesselate)
// (note: width and height are the actual vertex size, this produces
-//  (width-1)*(height-1)*2 triangles, 3 elements each)
+// (width-1)*(height-1)*2 triangles, 3 elements each)
void Q3PatchTriangleElements(int *elements, int width, int height, int firstvertex)
{
int x, y, row0, row1;
index af9ba15..6555a5a 100644 (file)
--- a/curves.h
+++ b/curves.h
@@ -2,6 +2,23 @@
#ifndef CURVES_H
#define CURVES_H

+#define PATCH_LODS_NUM 2
+#define PATCH_LOD_COLLISION 0
+#define PATCH_LOD_VISUAL 1
+
+typedef struct patchinfo_s
+{
+       int xsize, ysize;
+       struct {
+               int xtess, ytess;
+       } lods[PATCH_LODS_NUM];
+} patchinfo_t;
+
+// Calculate number of resulting vertex rows/columns by given patch size and tesselation factor
+// When tess=0 it means that we reduce detalization of base 3x3 patches by removing middle row and column
+// "DimForTess" is "DIMension FOR TESSelation factor"
+int Q3PatchDimForTess(int size, int tess);
+
// usage:
// to expand a 5x5 patch to 21x21 vertices (4x4 tesselation), one might use this call:
// Q3PatchSubdivideFloat(3, sizeof(float), outvertices, 5, 5, sizeof(float), patchvertices, 4, 4);
@@ -16,5 +33,7 @@ int Q3PatchTesselationOnY(int patchwidth, int patchheight, int components, const
//  (width-1)*(height-1)*2 triangles, 3 elements each)
void Q3PatchTriangleElements(int *elements, int width, int height, int firstvertex);

+int Q3PatchAdjustTesselation(int numcomponents, patchinfo_t *patch1, float *patchvertices1, patchinfo_t *patch2, float *patchvertices2);
+
#endif

index 1a92b2f..df122f6 100644 (file)
@@ -32,11 +32,11 @@ cvar_t r_novis = {0, "r_novis", "0", "draws whole level, see also sv_cullentitie
cvar_t r_picmipworld = {CVAR_SAVE, "r_picmipworld", "1", "whether gl_picmip shall apply to world textures too"};
cvar_t r_nosurftextures = {0, "r_nosurftextures", "0", "pretends there was no texture lump found in the q1bsp/hlbsp loading (useful for debugging this rare case)"};
cvar_t r_subdivisions_tolerance = {0, "r_subdivisions_tolerance", "4", "maximum error tolerance on curve subdivision for rendering purposes (in other words, the curves will be given as many polygons as necessary to represent curves at this quality)"};
-cvar_t r_subdivisions_mintess = {0, "r_subdivisions_mintess", "1", "minimum number of subdivisions (values above 1 will smooth curves that don't need it)"};
+cvar_t r_subdivisions_mintess = {0, "r_subdivisions_mintess", "0", "minimum number of subdivisions (values above 0 will smooth curves that don't need it)"};
cvar_t r_subdivisions_maxtess = {0, "r_subdivisions_maxtess", "1024", "maximum number of subdivisions (prevents curves beyond a certain detail level, limits smoothing)"};
cvar_t r_subdivisions_maxvertices = {0, "r_subdivisions_maxvertices", "65536", "maximum vertices allowed per subdivided curve"};
cvar_t r_subdivisions_collision_tolerance = {0, "r_subdivisions_collision_tolerance", "15", "maximum error tolerance on curve subdivision for collision purposes (usually a larger error tolerance than for rendering)"};
-cvar_t r_subdivisions_collision_mintess = {0, "r_subdivisions_collision_mintess", "1", "minimum number of subdivisions (values above 1 will smooth curves that don't need it)"};
+cvar_t r_subdivisions_collision_mintess = {0, "r_subdivisions_collision_mintess", "0", "minimum number of subdivisions (values above 0 will smooth curves that don't need it)"};
cvar_t r_subdivisions_collision_maxtess = {0, "r_subdivisions_collision_maxtess", "1024", "maximum number of subdivisions (prevents curves beyond a certain detail level, limits smoothing)"};
cvar_t r_subdivisions_collision_maxvertices = {0, "r_subdivisions_collision_maxvertices", "4225", "maximum vertices allowed per subdivided curve"};
cvar_t mod_q3bsp_curves_collisions = {0, "mod_q3bsp_curves_collisions", "1", "enables collisions with curves (SLOW)"};
@@ -4675,15 +4675,13 @@ static void Mod_Q3BSP_LoadLightmaps(lump_t *l, lump_t *faceslump)

typedef struct patchtess_s
{
-       qboolean grouped;
+       patchinfo_t info;
+
+       // Auxiliary data used only by patch loading code in Mod_Q3BSP_LoadFaces
int surface_id;
-       int xtess, ytess;
-       int xsize, ysize;
-       int cxtess, cytess;
-       int cxsize, cysize;
float lodgroup;
-}
-patchtess_t;
+       float *originalvertex3f;
+patchtess_t;

#define PATCHTESS_SAME_LODGROUP(a,b) \
( \
@@ -4699,7 +4697,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, finalwidth, finalheight, xtess, ytess, finalvertices, finaltriangles, firstvertex, firstelement, type, oldnumtriangles, oldnumtriangles2, meshvertices, meshtriangles, numvertices, numtriangles, groupsize, cxtess, cytess;
+       int i, oldi, j, n, count, invalidelements, patchsize, finalwidth, finalheight, xtess, ytess, finalvertices, finaltriangles, firstvertex, firstelement, type, oldnumtriangles, oldnumtriangles2, meshvertices, meshtriangles, numvertices, numtriangles, cxtess, cytess;
float lightmaptcbase, lightmaptcscale;
//int *originalelement3i;
//int *originalneighbor3i;
@@ -4713,6 +4711,7 @@ static void Mod_Q3BSP_LoadFaces(lump_t *l)
float *v;
patchtess_t *patchtess = NULL;
int patchtesscount = 0;
+       qboolean again;

in = (q3dface_t *)(mod_base + l->fileofs);
if (l->filelen % sizeof(*in))
@@ -4827,8 +4826,8 @@ static void Mod_Q3BSP_LoadFaces(lump_t *l)
xtess = bound(r_subdivisions_mintess.integer, xtess, r_subdivisions_maxtess.integer);
ytess = bound(r_subdivisions_mintess.integer, ytess, r_subdivisions_maxtess.integer);
// bound to sanity settings
-                       xtess = bound(1, xtess, 1024);
-                       ytess = bound(1, ytess, 1024);
+                       xtess = bound(0, xtess, 1024);
+                       ytess = bound(0, ytess, 1024);

// lower quality collision patches! Same procedure as before, but different cvars
// convert patch to Q3FACETYPE_MESH
@@ -4838,25 +4837,25 @@ static void Mod_Q3BSP_LoadFaces(lump_t *l)
cxtess = bound(r_subdivisions_collision_mintess.integer, cxtess, r_subdivisions_collision_maxtess.integer);
cytess = bound(r_subdivisions_collision_mintess.integer, cytess, r_subdivisions_collision_maxtess.integer);
// bound to sanity settings
-                       cxtess = bound(1, cxtess, 1024);
-                       cytess = bound(1, cytess, 1024);
+                       cxtess = bound(0, cxtess, 1024);
+                       cytess = bound(0, cytess, 1024);

// store it for the LOD grouping step
+                       patchtess[patchtesscount].info.xsize = patchsize;
+                       patchtess[patchtesscount].info.ysize = patchsize;
+                       patchtess[patchtesscount].info.lods[PATCH_LOD_VISUAL].xtess = xtess;
+                       patchtess[patchtesscount].info.lods[PATCH_LOD_VISUAL].ytess = ytess;
+                       patchtess[patchtesscount].info.lods[PATCH_LOD_COLLISION].xtess = cxtess;
+                       patchtess[patchtesscount].info.lods[PATCH_LOD_COLLISION].ytess = cytess;
+
patchtess[patchtesscount].surface_id = i;
-                       patchtess[patchtesscount].grouped = false;
-                       patchtess[patchtesscount].xtess = xtess;
-                       patchtess[patchtesscount].ytess = ytess;
-                       patchtess[patchtesscount].xsize = patchsize;
-                       patchtess[patchtesscount].ysize = patchsize;
patchtess[patchtesscount].lodgroup = in->specific.patch.mins;
patchtess[patchtesscount].lodgroup = in->specific.patch.mins;
patchtess[patchtesscount].lodgroup = in->specific.patch.mins;
patchtess[patchtesscount].lodgroup = in->specific.patch.maxs;
patchtess[patchtesscount].lodgroup = in->specific.patch.maxs;
patchtess[patchtesscount].lodgroup = in->specific.patch.maxs;
-
-                       patchtess[patchtesscount].cxtess = cxtess;
-                       patchtess[patchtesscount].cytess = cytess;
+                       patchtess[patchtesscount].originalvertex3f = originalvertex3f;
++patchtesscount;
break;
case Q3FACETYPE_FLARE:
static void Mod_Q3BSP_LoadFaces(lump_t *l)
meshtriangles += out->num_triangles;
}

-       for(i = 0; i < patchtesscount; ++i)
+       // Fix patches tesselations so that they make no seams
+       do
{
-               if(patchtess[i].grouped) // already grouped
-                       continue;
-
-               // get the highest required tess parameters for this group
-               groupsize = 0;
-               xtess = ytess = 0;
-               cxtess = cytess = 0;
-               for(j = 0; j < patchtesscount; ++j)
+               again = false;
+               for(i = 0; i < patchtesscount; ++i)
{
-                       if(patchtess[j].grouped) // already grouped
-                               continue;
-                       if(!PATCHTESS_SAME_LODGROUP(patchtess[i], patchtess[j]))
-                               continue;
-                       if(patchtess[j].xtess > xtess)
-                               xtess = patchtess[j].xtess;
-                       if(patchtess[j].ytess > ytess)
-                               ytess = patchtess[j].ytess;
-                       if(patchtess[j].cxtess > cxtess)
-                               cxtess = patchtess[j].cxtess;
-                       if(patchtess[j].cytess > cytess)
-                               cytess = patchtess[j].cytess;
-                       ++groupsize;
-               }
-
-               if(groupsize == 0)
-               {
-                       Con_Printf("ERROR: patch %d isn't in any LOD group (1)?!?\n", patchtess[i].surface_id);
-                       continue;
-               }
-
-               // bound to user limit on vertices
-               for(;;)
-               {
-                       numvertices = 0;
-                       numtriangles = 0;
-
-                       for(j = 0; j < patchtesscount; ++j)
+                       for(j = i+1; j < patchtesscount; ++j)
{
-                               if(patchtess[j].grouped) // already grouped
+                               if (!PATCHTESS_SAME_LODGROUP(patchtess[i], patchtess[j]))
continue;
-                               if(!PATCHTESS_SAME_LODGROUP(patchtess[i], patchtess[j]))
-                                       continue;
-
-                               finalwidth = (patchtess[j].xsize - 1) * xtess + 1;
-                               finalheight = (patchtess[j].ysize - 1) * ytess + 1;
-                               numvertices += finalwidth * finalheight;
-                               numtriangles += (finalwidth - 1) * (finalheight - 1) * 2;
-                       }

-                       if(xtess <= 1 && ytess <= 1)
-                               break;
-
-                       if(numvertices > min(r_subdivisions_maxvertices.integer, 262144) * groupsize)
-                       {
-                               if (xtess > ytess)
-                                       xtess--;
-                               else
-                                       ytess--;
-                               continue; // try again
+                               if (Q3PatchAdjustTesselation(3, &patchtess[i].info, patchtess[i].originalvertex3f, &patchtess[j].info, patchtess[j].originalvertex3f) )
+                                       again = true;
}
-
-                       break;
}
+       }
+       while (again);

-               // bound to user limit on vertices (collision)
-               for(;;)
-               {
-                       numvertices = 0;
-                       numtriangles = 0;
-
-                       for(j = 0; j < patchtesscount; ++j)
-                       {
-                               if(patchtess[j].grouped) // already grouped
-                                       continue;
-                               if(!PATCHTESS_SAME_LODGROUP(patchtess[i], patchtess[j]))
-                                       continue;
-
-                               finalwidth = (patchtess[j].xsize - 1) * cxtess + 1;
-                               finalheight = (patchtess[j].ysize - 1) * cytess + 1;
-                               numvertices += finalwidth * finalheight;
-                               numtriangles += (finalwidth - 1) * (finalheight - 1) * 2;
-                       }
-
-                       if(cxtess <= 1 && cytess <= 1)
-                               break;
-
-                       if(numvertices > min(r_subdivisions_collision_maxvertices.integer, 262144) * groupsize)
-                       {
-                               if (cxtess > cytess)
-                                       cxtess--;
-                               else
-                                       cytess--;
-                               continue; // try again
-                       }
-
-                       break;
-               }
-
-               for(j = 0; j < patchtesscount; ++j)
-               {
-                       if(patchtess[j].grouped) // already grouped
-                               continue;
-                       if(!PATCHTESS_SAME_LODGROUP(patchtess[i], patchtess[j]))
-                               continue;
-
-                       finalwidth = (patchtess[j].xsize - 1) * xtess + 1;
-                       finalheight = (patchtess[j].ysize - 1) * ytess + 1;
-                       numvertices = finalwidth * finalheight;
-                       numtriangles = (finalwidth - 1) * (finalheight - 1) * 2;
-
-                       oldout[patchtess[j].surface_id].num_vertices = numvertices;
-                       oldout[patchtess[j].surface_id].num_triangles = numtriangles;
-                       meshvertices += oldout[patchtess[j].surface_id].num_vertices;
-                       meshtriangles += oldout[patchtess[j].surface_id].num_triangles;
+       // Calculate resulting number of triangles
+       for(i = 0; i < patchtesscount; ++i)
+       {
+               finalwidth = Q3PatchDimForTess(patchtess[i].info.xsize, patchtess[i].info.lods[PATCH_LOD_VISUAL].xtess);
+               finalheight = Q3PatchDimForTess(patchtess[i].info.ysize,patchtess[i].info.lods[PATCH_LOD_VISUAL].ytess);
+               numvertices = finalwidth * finalheight;
+               numtriangles = (finalwidth - 1) * (finalheight - 1) * 2;

-                       patchtess[j].grouped = true;
-                       patchtess[j].xtess = xtess;
-                       patchtess[j].ytess = ytess;
-                       patchtess[j].cxtess = cxtess;
-                       patchtess[j].cytess = cytess;
-               }
+               oldout[patchtess[i].surface_id].num_vertices = numvertices;
+               oldout[patchtess[i].surface_id].num_triangles = numtriangles;
+               meshvertices += oldout[patchtess[i].surface_id].num_vertices;
+               meshtriangles += oldout[patchtess[i].surface_id].num_triangles;
}

i = oldi;
@@ -5046,24 +4952,24 @@ static void Mod_Q3BSP_LoadFaces(lump_t *l)
originaltexcoordlightmap2f = loadmodel->brushq3.data_texcoordlightmap2f + firstvertex * 2;
originalcolor4f = loadmodel->brushq3.data_color4f + firstvertex * 4;

-                       xtess = ytess = cxtess = cytess = 0;
+                       xtess = ytess = cxtess = cytess = -1;
for(j = 0; j < patchtesscount; ++j)
-                               if(patchtess[j].grouped && patchtess[j].surface_id == i)
+                               if(patchtess[j].surface_id == i)
{
-                                       xtess = patchtess[j].xtess;
-                                       ytess = patchtess[j].ytess;
-                                       cxtess = patchtess[j].cxtess;
-                                       cytess = patchtess[j].cytess;
+                                       xtess = patchtess[j].info.lods[PATCH_LOD_VISUAL].xtess;
+                                       ytess = patchtess[j].info.lods[PATCH_LOD_VISUAL].ytess;
+                                       cxtess = patchtess[j].info.lods[PATCH_LOD_COLLISION].xtess;
+                                       cytess = patchtess[j].info.lods[PATCH_LOD_COLLISION].ytess;
break;
}
-                       if(xtess == 0)
+                       if(xtess == -1)
{
-                               Con_Printf("ERROR: patch %d isn't in any LOD group (2)?!?\n", i);
-                               xtess = ytess = cxtess = cytess = 1;
+                               Con_Printf("ERROR: patch %d isn't preprocessed?!?\n", i);
+                               xtess = ytess = cxtess = cytess = 0;
}

-                       finalwidth = ((patchsize - 1) * xtess) + 1;
-                       finalheight = ((patchsize - 1) * ytess) + 1;
+                       finalwidth = Q3PatchDimForTess(patchsize,xtess); //((patchsize - 1) * xtess) + 1;
+                       finalheight = Q3PatchDimForTess(patchsize,ytess); //((patchsize - 1) * ytess) + 1;
finalvertices = finalwidth * finalheight;
finaltriangles = (finalwidth - 1) * (finalheight - 1) * 2;
type = Q3FACETYPE_MESH;
@@ -5075,7 +4981,9 @@ static void Mod_Q3BSP_LoadFaces(lump_t *l)
Q3PatchTesselateFloat(2, sizeof(float), (loadmodel->surfmesh.data_texcoordlightmap2f + 2 * out->num_firstvertex), patchsize, patchsize, sizeof(float), originaltexcoordlightmap2f, xtess, ytess);
Q3PatchTesselateFloat(4, sizeof(float), (loadmodel->surfmesh.data_lightmapcolor4f + 4 * out->num_firstvertex), patchsize, patchsize, sizeof(float), originalcolor4f, xtess, ytess);
Q3PatchTriangleElements((loadmodel->surfmesh.data_element3i + 3 * out->num_firsttriangle), finalwidth, finalheight, out->num_firstvertex);
+
out->num_triangles = Mod_RemoveDegenerateTriangles(out->num_triangles, (loadmodel->surfmesh.data_element3i + 3 * out->num_firsttriangle), (loadmodel->surfmesh.data_element3i + 3 * out->num_firsttriangle), loadmodel->surfmesh.data_vertex3f);
+
if (developer.integer >= 100)
{
if (out->num_triangles < finaltriangles)
@@ -5085,8 +4993,8 @@ static void Mod_Q3BSP_LoadFaces(lump_t *l)
}
// q3map does not put in collision brushes for curves... ugh
// build the lower quality collision geometry
-                       finalwidth = ((patchsize - 1) * cxtess) + 1;
-                       finalheight = ((patchsize - 1) * cytess) + 1;
+                       finalwidth = Q3PatchDimForTess(patchsize,cxtess); //((patchsize - 1) * cxtess) + 1;
+                       finalheight = Q3PatchDimForTess(patchsize,cytess); //((patchsize - 1) * cytess) + 1;
finalvertices = finalwidth * finalheight;
finaltriangles = (finalwidth - 1) * (finalheight - 1) * 2;