PMESH.CPP

Go to the documentation of this file.

/*
===========================================================================
Copyright (C) 1999-2005 Id Software, Inc.

This file is part of Quake III Arena source code.

Quake III Arena source code is free software; you can redistribute it
and/or modify it under the terms of the GNU General Public License as
published by the Free Software Foundation; either version 2 of the License,
or (at your option) any later version.

Quake III Arena source code is distributed in the hope that it will be
useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with Foobar; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
===========================================================================
*/
// 
// Preliminary patch stuff
//
// 

#include "stdafx.h"
#include "qe3.h"
#include "DialogInfo.h"
#include "CapDialog.h"

// externs
extern void MemFile_fprintf(CMemFile* pMemFile, const char* pText, ...);
extern face_t *Face_Alloc( void );
void _Write3DMatrix (FILE *f, int y, int x, int z, float *m);
void _Write3DMatrix (CMemFile *f, int y, int x, int z, float *m);



#define CBLOCK_SUBDIVISIONS 6 


patchMesh_t* MakeNewPatch()
{
  patchMesh_t *pm = reinterpret_cast<patchMesh_t*>(qmalloc(sizeof(patchMesh_t)));
  if (g_qeglobals.bSurfacePropertiesPlugin)
  {
      pm->pData = static_cast<void *>( g_SurfaceTable.m_pfnPatchAlloc( pm ) );
  }
  return pm;
}

// FIXME: this needs to be dynamic
//#define   MAX_PATCH_MESHES    4096
//patchMesh_t       patchMeshes[MAX_PATCH_MESHES];
//int numPatchMeshes = 0;

// used for a save spot
patchMesh_t patchSave;

// Tracks the selected patch for point manipulation/update. FIXME: Need to revert back to a generalized 
// brush approach
//--int  g_nSelectedPatch = -1;  

// HACK: for tracking which view generated the click
// as we dont want to deselect a point on a same point
// click if it is from a different view
int  g_nPatchClickedView = -1;
bool g_bSameView = false;


// globals
bool g_bPatchShowBounds = true;
bool g_bPatchWireFrame = false;
bool g_bPatchWeld = true;
bool g_bPatchDrillDown = true;
bool g_bPatchInsertMode = false;
bool g_bPatchBendMode = false;
int  g_nPatchBendState = -1;
int  g_nPatchInsertState = -1;
int  g_nBendOriginIndex = 0;
vec3_t g_vBendOrigin;

bool g_bPatchAxisOnRow = true;
int  g_nPatchAxisIndex = 0;
bool g_bPatchLowerEdge = true;

// BEND states
enum
{
  BEND_SELECT_ROTATION = 0,
  BEND_SELECT_ORIGIN,
  BEND_SELECT_EDGE,
  BEND_BENDIT,
  BEND_STATE_COUNT
};

const char *g_pBendStateMsg[] =
{
  "Use TAB to cycle through available bend axis. Press ENTER when the desired one is highlighted.",
  "Use TAB to cycle through available rotation axis. This will LOCK around that point. You may also use Shift + Middle Click to select an arbitrary point. Press ENTER when the desired one is highlighted",
  "Use TAB to choose which side to bend. Press ENTER when the desired one is highlighted.",
  "Use the MOUSE to bend the patch. It uses the same ui rules as Free Rotation. Press ENTER to accept the bend, press ESC to abandon it and exit Bend mode",
  ""
};

// INSERT states
enum
{
  INSERT_SELECT_EDGE = 0,
  INSERT_STATE_COUNT
};

const char* g_pInsertStateMsg[] =
{
  "Use TAB to cycle through available rows/columns for insertion/deletion. Press INS to insert at the highlight, DEL to remove the pair"
};


float *g_InversePoints[1024];

const float fFullBright = 1.0;
const float fLowerLimit = .50;
const float fDec = .05;
void _SetColor(face_t* f, float fColor[3])
{
  return;
  fColor[0] = f->d_color[0];
  fColor[1] = f->d_color[1];
  fColor[2] = f->d_color[2];
  qglColor3fv(fColor);
}


void _DecColor(float fColor[3])
{
  return;
  fColor[0] -= fDec;
  fColor[1] -= fDec ;
  fColor[2] -= fDec;
  for (int i = 0; i < 3; i++)
  {
    if (fColor[i] <= fLowerLimit)
    {
      fColor[0] = fFullBright;
      fColor[1] = fFullBright;
      fColor[2] = fFullBright;
      break;
    }
  }
    qglColor3fv(fColor);
}

vec_t __VectorNormalize (vec3_t in, vec3_t out)
{
    vec_t   length, ilength;

    length = sqrt (in[0]*in[0] + in[1]*in[1] + in[2]*in[2]);
    if (length == 0)
    {
        VectorClear (out);
        return 0;
    }

    ilength = 1.0/length;
    out[0] = in[0]*ilength;
    out[1] = in[1]*ilength;
    out[2] = in[2]*ilength;

    return length;
}


void Patch_SetType(patchMesh_t *p, int nType)
{
  p->type = (p->type & PATCH_STYLEMASK) | nType;
}

void Patch_SetStyle(patchMesh_t *p, int nStyle)
{
  p->type = (p->type & PATCH_TYPEMASK) | nStyle;
}

/*
==================
Patch_MemorySize
==================
*/
int Patch_MemorySize(patchMesh_t *p)
{
    return _msize(p);
}



/*
===============
InterpolateInteriorPoints
===============
*/
void InterpolateInteriorPoints( patchMesh_t *p ) 
{
    int     i, j, k;
    int     next, prev;

    for ( i = 0 ; i < p->width ; i += 2 ) 
  {

    next = ( i == p->width - 1 ) ? 1 : ( i + 1 ) % p->width;
    prev = ( i == 0 ) ? p->width - 2 : i - 1;

#if 0
        if ( i == 0 ) 
    {
            next = ( i + 1 ) % p->width;
            prev = p->width - 2;              // joined wrap case
        } 
    else if ( i == p->width - 1 ) 
    {
            next = 1;
            prev = i - 1;
        } 
    else 
    {
            next = ( i + 1 ) % p->width;
            prev = i - 1;
        }
#endif

        for ( j = 0 ; j < p->height ; j++ ) 
    {
            for ( k = 0 ; k < 3 ; k++ ) 
      {
                p->ctrl[i][j].xyz[k] = ( p->ctrl[next][j].xyz[k] + p->ctrl[prev][j].xyz[k] ) * 0.5;
            }
        }
    }
}

/*
=================
MakeMeshNormals

=================
*/
int neighbors[8][2] = {
    {0,1}, {1,1}, {1,0}, {1,-1}, {0,-1}, {-1,-1}, {-1,0}, {-1,1}
};

void Patch_MeshNormals(patchMesh_t *in ) 
{
    int     i, j, k, dist;
    vec3_t  normal;
    vec3_t  sum;
    int     count;
    vec3_t  base;
    vec3_t  delta;
    int     x, y;
    drawVert_t  *dv;
    vec3_t      around[8], temp;
    qboolean    good[8];
    qboolean    wrapWidth, wrapHeight;
    float       len;

    wrapWidth = false;
    for ( i = 0 ; i < in->height ; i++ ) 
  {

        VectorSubtract( in->ctrl[0][i].xyz, 
                          in->ctrl[in->width-1][i].xyz, delta );
        len = VectorLength( delta );
        if ( len > 1.0 ) 
    {
            break;
        }
    }
    if ( i == in->height ) 
  {
        wrapWidth = true;
    }

    wrapHeight = false;
    for ( i = 0 ; i < in->width ; i++ ) 
  {
        VectorSubtract( in->ctrl[i][0].xyz, 
                          in->ctrl[i][in->height-1].xyz, delta );
        len = VectorLength( delta );
        if ( len > 1.0 ) 
    {
            break;
        }
    }
    if ( i == in->width) 
  {
        wrapHeight = true;
    }


    for ( i = 0 ; i < in->width ; i++ ) 
  {
        for ( j = 0 ; j < in->height ; j++ ) 
    {
            count = 0;
            //--dv = reinterpret_cast<drawVert_t*>(in.ctrl[j*in.width+i]);
            dv = &in->ctrl[i][j];
            VectorCopy( dv->xyz, base );
            for ( k = 0 ; k < 8 ; k++ ) 
      {
                VectorClear( around[k] );
                good[k] = false;

                for ( dist = 1 ; dist <= 3 ; dist++ ) 
        {
                    x = i + neighbors[k][0] * dist;
                    y = j + neighbors[k][1] * dist;
                    if ( wrapWidth ) 
          {
                        if ( x < 0 ) 
            {
                            x = in->width - 1 + x;
                        } 
            else if ( x >= in->width ) 
            {
                            x = 1 + x - in->width;
                        }
                    }
                    if ( wrapHeight ) 
          {
                        if ( y < 0 ) 
            {
                            y = in->height - 1 + y;
                        } 
            else if ( y >= in->height ) 
            {
                            y = 1 + y - in->height;
                        }
                    }

                    if ( x < 0 || x >= in->width || y < 0 || y >= in->height ) 
          {
                        break;                  // edge of patch
                    }
                    //--VectorSubtract( in.ctrl[y*in.width+x]->xyz, base, temp );
                    VectorSubtract( in->ctrl[x][y].xyz, base, temp );
                    if ( __VectorNormalize( temp, temp ) == 0 ) 
          {
                        continue;               // degenerate edge, get more dist
                    } 
          else                 
          {
                        good[k] = true;
                        VectorCopy( temp, around[k] );
                        break;                  // good edge
                    }
                }
            }

            VectorClear( sum );
            for ( k = 0 ; k < 8 ; k++ ) 
      {
                if ( !good[k] || !good[(k+1)&7] ) 
        {
                    continue;   // didn't get two points
                }
                CrossProduct( around[(k+1)&7], around[k], normal );
                if ( __VectorNormalize( normal, normal ) == 0 ) 
        {
                    continue;
                }
                VectorAdd( normal, sum, sum );
                count++;
            }
            if ( count == 0 ) 
      {
        //printf("bad normal\n");
                count = 1;
        //continue;
            }
            __VectorNormalize( sum, dv->normal );
        }
    }
}




/*
==================
Patch_CalcBounds
==================
*/
void Patch_CalcBounds(patchMesh_t *p, vec3_t& vMin, vec3_t& vMax)
{
  vMin[0] = vMin[1] = vMin[2] = 99999;
  vMax[0] = vMax[1] = vMax[2] = -99999;

  p->bDirty = true;
  for (int w = 0; w < p->width; w++)
  {
    for (int h = 0; h < p->height; h++)
    {
      for (int j = 0; j < 3; j++)
      {
        float f = p->ctrl[w][h].xyz[j];
        if (f < vMin[j])
          vMin[j] = f;
        if (f > vMax[j])
          vMax[j] = f;
      }
    }
  }
}

/*
==================
Brush_RebuildBrush
==================
*/
void Brush_RebuildBrush(brush_t *b, vec3_t vMins, vec3_t vMaxs)
{
  //
  // Total hack job 
  // Rebuilds a brush
    int     i, j;
    face_t  *f, *next;
    vec3_t  pts[4][2];
  texdef_t  texdef;
    // free faces

  for (j = 0; j < 3; j++)
  {
    if ((int)vMins[j] == (int)vMaxs[j])
    {
      vMins[j] -= 4;
      vMaxs[j] += 4;
    }
  }

  
  for (f=b->brush_faces ; f ; f=next)
    {
        next = f->next;
    if (f)
      texdef = f->texdef;
    Face_Free( f );
    }

  b->brush_faces = NULL;

  // left the last face so we can use its texdef

    for (i=0 ; i<3 ; i++)
        if (vMaxs[i] < vMins[i])
            Error ("Brush_RebuildBrush: backwards");

    pts[0][0][0] = vMins[0];
    pts[0][0][1] = vMins[1];
    
    pts[1][0][0] = vMins[0];
    pts[1][0][1] = vMaxs[1];
    
    pts[2][0][0] = vMaxs[0];
    pts[2][0][1] = vMaxs[1];
    
    pts[3][0][0] = vMaxs[0];
    pts[3][0][1] = vMins[1];
    
    for (i=0 ; i<4 ; i++)
    {
        pts[i][0][2] = vMins[2];
        pts[i][1][0] = pts[i][0][0];
        pts[i][1][1] = pts[i][0][1];
        pts[i][1][2] = vMaxs[2];
    }

    for (i=0 ; i<4 ; i++)
    {
        f = Face_Alloc();
        f->texdef = texdef;
        f->texdef.flags &= ~SURF_KEEP;
        f->texdef.contents &= ~CONTENTS_KEEP;
        if ( b->patchBrush )
        {
            f->texdef.flags |= SURF_PATCH; 
        }
        f->next = b->brush_faces;
        b->brush_faces = f;
        j = (i+1)%4;

        VectorCopy (pts[j][1], f->planepts[0]);
        VectorCopy (pts[i][1], f->planepts[1]);
        VectorCopy (pts[i][0], f->planepts[2]);
    }
    
    f = Face_Alloc();
    f->texdef = texdef;
    f->texdef.flags &= ~SURF_KEEP;
    f->texdef.contents &= ~CONTENTS_KEEP;
    if ( b->patchBrush )
    {
        f->texdef.flags |= SURF_PATCH; 
    }
    f->next = b->brush_faces;
    b->brush_faces = f;

    VectorCopy (pts[0][1], f->planepts[0]);
    VectorCopy (pts[1][1], f->planepts[1]);
    VectorCopy (pts[2][1], f->planepts[2]);

    f = Face_Alloc();
    f->texdef = texdef;
    f->texdef.flags &= ~SURF_KEEP;
    f->texdef.contents &= ~CONTENTS_KEEP;
    if ( b->patchBrush )
    {
        f->texdef.flags |= SURF_PATCH; 
    }
    f->next = b->brush_faces;
    b->brush_faces = f;

    VectorCopy (pts[2][0], f->planepts[0]);
    VectorCopy (pts[1][0], f->planepts[1]);
    VectorCopy (pts[0][0], f->planepts[2]);

  Brush_Build(b);
}

void WINAPI Patch_Rebuild(patchMesh_t *p)
{
  vec3_t vMin, vMax;
  Patch_CalcBounds(p, vMin, vMax);
  Brush_RebuildBrush(p->pSymbiot, vMin, vMax);
  p->bDirty = true;
}

/*
==================
AddBrushForPatch
==================
 adds a patch brush and ties it to this patch id
*/
brush_t* AddBrushForPatch(patchMesh_t *pm, bool bLinkToWorld )
{
  // find the farthest points in x,y,z
  vec3_t vMin, vMax;
  Patch_CalcBounds(pm, vMin, vMax);

  for (int j = 0; j < 3; j++)
  {
    if (vMin[j] == vMax[j])
    {
      vMin[j] -= 4;
      vMax[j] += 4;
    }
  }

  brush_t *b = Brush_Create(vMin, vMax, &g_qeglobals.d_texturewin.texdef);
    face_t      *f;
    for (f=b->brush_faces ; f ; f=f->next) 
  {
        f->texdef.flags |= SURF_PATCH; 
    }

  // FIXME: this entire type of linkage needs to be fixed
  b->pPatch = pm;
  pm->pSymbiot = b;
  pm->bSelected = false;
  pm->bOverlay = false;
  pm->bDirty = true;
  pm->nListID = -1;

  if (bLinkToWorld)
  {
    Brush_AddToList (b, &active_brushes);
      Entity_LinkBrush (world_entity, b);
    Brush_Build(b);
  }

  return b;
}

void Patch_SetPointIntensities(int n)
{
#if 0
    patchMesh_t *p = patchMeshes[n];
  for (int i = 0; i < p->width; i++)
  {
    for (int j = 0; j < p->height; j++)
    {

    }
  }
#endif
}

// very approximate widths and heights

/*
==================
Patch_Width
==================
*/
float Patch_Width(patchMesh_t *p)
{
  float f = 0;
  for (int i = 0; i < p->width-1; i++)
  {
    vec3_t vTemp;
    VectorSubtract(p->ctrl[i][0].xyz, p->ctrl[i+1][0].xyz, vTemp);
    f += VectorLength(vTemp);
  }
  return f;
}

float Patch_WidthDistanceTo(patchMesh_t *p, int j)
{
  float f = 0;
  for (int i = 0; i < j; i++)
  {
    vec3_t vTemp;
    VectorSubtract(p->ctrl[i][0].xyz, p->ctrl[i+1][0].xyz, vTemp);
    f += VectorLength(vTemp);
  }
  return f;
}



/*
==================
Patch_Height
==================
*/
float Patch_Height(patchMesh_t *p)
{
  float f = 0;
  for (int i = 0; i < p->height-1; i++)
  {
    vec3_t vTemp;
    VectorSubtract(p->ctrl[0][i].xyz, p->ctrl[0][i+1].xyz, vTemp);
    f += VectorLength(vTemp);
  }
  return f;
}

float Patch_HeightDistanceTo(patchMesh_t *p, int j)
{
  float f = 0;
  for (int i = 0; i < j; i++)
  {
    vec3_t vTemp;
    VectorSubtract(p->ctrl[0][i].xyz, p->ctrl[0][i+1].xyz, vTemp);
    f += VectorLength(vTemp);
  }
  return f;
}



/*
==================
Patch_Naturalize
==================
texture = TotalTexture * LengthToThisControlPoint / TotalControlPointLength

dist( this control point to first control point ) / dist ( last control pt to first)
*/
void Patch_Naturalize(patchMesh_t *p)
{
  int nWidth = (g_PrefsDlg.m_bHiColorTextures == TRUE) ? p->d_texture->width * 0.5 : p->d_texture->width;
  int nHeight = (g_PrefsDlg.m_bHiColorTextures == TRUE) ? p->d_texture->height * 0.5 : p->d_texture->height;
  float fPWidth = Patch_Width(p);
  float fPHeight = Patch_Height(p);
  float xAccum = 0;
  for ( int i = 0 ; i < p->width ; i++ ) 
  {
    float yAccum = 0;
      for ( int j = 0 ; j < p->height ; j++ ) 
    {
          p->ctrl[i][j].st[0] = (fPWidth / nWidth) * xAccum / fPWidth;
          p->ctrl[i][j].st[1] = (fPHeight / nHeight) * yAccum / fPHeight;
          yAccum = Patch_HeightDistanceTo(p,j+1);
      //p->ctrl[i][j][3] = (fPWidth / nWidth) * (float)i / (p->width - 1);
          //p->ctrl[i][j][4] = (fPHeight/ nHeight) * (float)j / (p->height - 1);
      }
    xAccum = Patch_WidthDistanceTo(p,i+1);
  }
  p->bDirty = true;
}

/*
  if (bIBevel)
  {
    VectorCopy(p->ctrl[1][0], p->ctrl[1][1]);
  }

  if (bIEndcap)
  {
    VectorCopy(p->ctrl[3][0], p->ctrl[4][1]);
    VectorCopy(p->ctrl[2][0], p->ctrl[3][1]);
    VectorCopy(p->ctrl[2][0], p->ctrl[2][1]);
    VectorCopy(p->ctrl[2][0], p->ctrl[1][1]);
    VectorCopy(p->ctrl[1][0], p->ctrl[0][1]);
    VectorCopy(p->ctrl[1][0], p->ctrl[0][2]);
    VectorCopy(p->ctrl[1][0], p->ctrl[1][2]);
    VectorCopy(p->ctrl[2][0], p->ctrl[2][2]);
    VectorCopy(p->ctrl[3][0], p->ctrl[3][2]);
    VectorCopy(p->ctrl[3][0], p->ctrl[4][2]);
  }
*/

int Index3By[][2] =
{
  {0,0},
  {1,0},
  {2,0},
  {2,1},
  {2,2},
  {1,2},
  {0,2},
  {0,1},
  {0,0},
  {0,0},
  {0,0},
  {0,0},
  {0,0},
  {0,0},
  {0,0}
};

int Index5By[][2] =
{
  {0,0},
  {1,0},
  {2,0},
  {3,0},
  {4,0},
  {4,1},
  {4,2},
  {4,3},
  {4,4},
  {3,4},
  {2,4},
  {1,4},
  {0,4},
  {0,3},
  {0,2},
  {0,1}
};



int Interior3By[][2] =
{
  {1,1}
};

int Interior5By[][2] =
{
  {1,1},
  {2,1},
  {3,1},
  {1,2},
  {2,2},
  {3,2},
  {1,3},
  {2,3},
  {3,3}
};

int Interior3ByCount = sizeof(Interior3By) / sizeof(int[2]);
int Interior5ByCount = sizeof(Interior5By) / sizeof(int[2]);

face_t* Patch_GetAxisFace(patchMesh_t *p)
{
  face_t *f = NULL;
  vec3_t vTemp;
  brush_t *b = p->pSymbiot;

    for (f = b->brush_faces ; f ; f = f->next) 
  {
    VectorSubtract(f->face_winding->points[1], f->face_winding->points[0], vTemp);
    int nScore = 0;

    // default edge faces on caps are 8 high so
    // as soon as we hit one that is bigger it should be on the right axis
    for (int j = 0; j < 3; j++)
    {
      if (vTemp[j] > 8)
        nScore++;
    }

    if (nScore > 0)
      break;
  }

  if (f == NULL)
    f = b->brush_faces;
  return f;
}

int g_nFaceCycle = 0;

face_t* nextFace(patchMesh_t *p)
{
  brush_t *b = p->pSymbiot;
  face_t *f = NULL;
  int n = 0;
    for (f = b->brush_faces ; f && n <= g_nFaceCycle; f = f->next) 
  {
    n++;
  }
  g_nFaceCycle++;
  if (g_nFaceCycle > 5)
  {
    g_nFaceCycle =0;
    f = b->brush_faces;
  }

  return f;
}


extern void EmitTextureCoordinates ( float *xyzst, qtexture_t *q, face_t *f);
void Patch_CapTexture(patchMesh_t *p, bool bFaceCycle = false)
{
  Patch_MeshNormals(p);
  face_t *f = (bFaceCycle) ? nextFace(p) : Patch_GetAxisFace(p);
  vec3_t vSave;
  VectorCopy(f->plane.normal, vSave);
  
  float fRotate = f->texdef.rotate;
  f->texdef.rotate = 0;
  float fScale[2];
  fScale[0] = f->texdef.scale[0];
  fScale[1] = f->texdef.scale[1];
  f->texdef.scale[0] = 0.5;
  f->texdef.scale[1] = 0.5;
  float fShift[2];
  fShift[0] = f->texdef.shift[0];
  fShift[1] = f->texdef.shift[1];
  f->texdef.shift[0] = 0;
  f->texdef.shift[1] = 0;
  
  for (int i = 0; i < p->width; i++)
  {
    for (int j = 0; j < p->height; j++)
    {
      if (!bFaceCycle)
      {
        VectorCopy(p->ctrl[i][j].normal, f->plane.normal);
      }
          EmitTextureCoordinates( p->ctrl[i][j].xyz, f->d_texture, f);
    }
  }
  VectorCopy(vSave, f->plane.normal);
  f->texdef.rotate = fRotate;
  f->texdef.scale[0] = fScale[0];
  f->texdef.scale[1] = fScale[1];
  f->texdef.shift[0] = fShift[0];
  f->texdef.shift[1] = fShift[1];
  p->bDirty = true;
}

void FillPatch(patchMesh_t *p, vec3_t v)
{
  for (int i = 0; i < p->width; i++)
  {
    for (int j = 0; j < p->height; j++)
    {
      VectorCopy(v, p->ctrl[i][j].xyz);
    }
  }
}

brush_t* Cap(patchMesh_t *pParent, bool bByColumn, bool bFirst)
{
  brush_t *b;
  patchMesh_t *p;
  vec3_t vMin, vMax;
  int i, j;

  bool bSmall = true;
  // make a generic patch
  if (pParent->width <= 9)
  {
    b = Patch_GenericMesh(3, 3, 2, false);
  }
  else
  {
    b = Patch_GenericMesh(5, 5, 2, false);
    bSmall = false;
  }

  if (!b)
  {
    Sys_Printf("Unable to cap. You may need to ungroup the patch.\n");
    return NULL;
  }

  p = b->pPatch;
  p->type |= PATCH_CAP;

  vMin[0] = vMin[1] = vMin[2] = 9999;
  vMax[0] = vMax[1] = vMax[2] = -9999;

  // we seam the column edge, FIXME: this might need to be able to seem either edge
  // 
  int nSize = (bByColumn) ? pParent->width : pParent->height;
  int nIndex = (bFirst) ? 0 : (bByColumn) ? pParent->height-1 : pParent->width-1;

  FillPatch(p, pParent->ctrl[0][nIndex].xyz);

  for (i = 0; i < nSize; i++)
  {
    if (bByColumn)
    {
      if (bSmall)
      {
        VectorCopy(pParent->ctrl[i][nIndex].xyz, p->ctrl[Index3By[i][0]][Index3By[i][1]].xyz);
      }
      else
      {
        VectorCopy(pParent->ctrl[i][nIndex].xyz, p->ctrl[Index5By[i][0]][Index5By[i][1]].xyz);
      }
    }
    else
    {
      if (bSmall)
      {
        VectorCopy(pParent->ctrl[nIndex][i].xyz, p->ctrl[Index3By[i][0]][Index3By[i][1]].xyz);
      }
      else
      {
        VectorCopy(pParent->ctrl[nIndex][i].xyz, p->ctrl[Index5By[i][0]][Index5By[i][1]].xyz);
      }
    }
  
    for (j = 0; j < 3; j++)
    {
      float f = (bSmall) ? p->ctrl[Index3By[i][0]][Index3By[i][1]].xyz[j] : p->ctrl[Index5By[i][0]][Index5By[i][1]].xyz[j];
      if (f < vMin[j])
        vMin[j] = f;
      if (f > vMax[j])
        vMax[j] = f;
    }
  }

  vec3_t vTemp;
  for (j = 0; j < 3; j++)
  {
    vTemp[j] = vMin[j] + abs((vMax[j] - vMin[j]) * 0.5);
  }

  int nCount = (bSmall) ? Interior3ByCount : Interior5ByCount;
  for (j = 0; j < nCount; j++)
  {
    if (bSmall)
    {
      VectorCopy(vTemp, p->ctrl[Interior3By[j][0]][Interior3By[j][1]].xyz);
    }
    else
    {
      VectorCopy(vTemp, p->ctrl[Interior5By[j][0]][Interior5By[j][1]].xyz);
    }
  }

  if (bFirst)
  {
    drawVert_t vertTemp;
    for (i = 0; i < p->width; i++)
    {
      for (j = 0; j < p->height / 2; j++)
      {
        memcpy(&vertTemp, &p->ctrl[i][p->height - 1- j], sizeof (drawVert_t));
        memcpy(&p->ctrl[i][p->height - 1 - j], &p->ctrl[i][j], sizeof(drawVert_t));
        memcpy(&p->ctrl[i][j], &vertTemp, sizeof(drawVert_t));
      }
    }
  }

  Patch_Rebuild(p);
  Patch_CapTexture(p);
  return p->pSymbiot;
}

brush_t* CapSpecial(patchMesh_t *pParent, int nType, bool bFirst)
{
  brush_t *b;
  patchMesh_t *p;
  vec3_t vMin, vMax, vTemp;
  int i, j;

  if (nType == CCapDialog::IENDCAP)
    b = Patch_GenericMesh(5, 3, 2, false);
  else
    b = Patch_GenericMesh(3, 3, 2, false);

  if (!b)
  {
    Sys_Printf("Unable to cap. Make sure you ungroup before re-capping.");
    return NULL;
  }

  p = b->pPatch;
  p->type |= PATCH_CAP;

  vMin[0] = vMin[1] = vMin[2] = 9999;
  vMax[0] = vMax[1] = vMax[2] = -9999;

  int nSize = pParent->width;
  int nIndex = (bFirst) ? 0 : pParent->height-1;

  // parent bounds are used for some things
  Patch_CalcBounds(pParent, vMin, vMax);

  for (j = 0; j < 3; j++)
  {
    vTemp[j] = vMin[j] + abs((vMax[j] - vMin[j]) * 0.5);
  }

  if (nType == CCapDialog::IBEVEL)
  {
    VectorCopy(pParent->ctrl[0][nIndex].xyz, p->ctrl[0][0].xyz);
    VectorCopy(pParent->ctrl[2][nIndex].xyz, p->ctrl[0][2].xyz);
    VectorCopy(pParent->ctrl[1][nIndex].xyz, p->ctrl[0][1].xyz);
    VectorCopy(pParent->ctrl[1][nIndex].xyz, p->ctrl[2][2].xyz);
    VectorCopy(pParent->ctrl[1][nIndex].xyz, p->ctrl[1][0].xyz);
    VectorCopy(pParent->ctrl[1][nIndex].xyz, p->ctrl[1][1].xyz);
    VectorCopy(pParent->ctrl[1][nIndex].xyz, p->ctrl[1][2].xyz);
    VectorCopy(pParent->ctrl[1][nIndex].xyz, p->ctrl[2][0].xyz);
    VectorCopy(pParent->ctrl[1][nIndex].xyz, p->ctrl[2][1].xyz);
  }
  else if (nType == CCapDialog::BEVEL)
  {
    vec3_t p1, p2, p3, p4, temp, dir;

    VectorCopy(pParent->ctrl[0][nIndex].xyz, p3);
    VectorCopy(pParent->ctrl[1][nIndex].xyz, p1);
    VectorCopy(pParent->ctrl[2][nIndex].xyz, p2);

    VectorSubtract(p3, p2, dir);
    VectorNormalize(dir);
    VectorSubtract(p1, p2, temp);
    vec_t dist = _DotProduct(temp, dir);

    VectorScale(dir, dist, temp);

    VectorAdd(p2, temp, temp);

    VectorSubtract(temp, p1, temp);
    VectorScale(temp, 2, temp);
    VectorAdd(p1, temp, p4);

    VectorCopy(p4, p->ctrl[0][0].xyz);
    VectorCopy(p4, p->ctrl[1][0].xyz);
    VectorCopy(p4, p->ctrl[0][1].xyz);
    VectorCopy(p4, p->ctrl[1][1].xyz);
    VectorCopy(p4, p->ctrl[0][2].xyz);
    VectorCopy(p4, p->ctrl[1][2].xyz);
    VectorCopy(p3, p->ctrl[2][0].xyz);
    VectorCopy(p1, p->ctrl[2][1].xyz);
    VectorCopy(p2, p->ctrl[2][2].xyz);

  }
  else if (nType == CCapDialog::ENDCAP)
  {
    VectorAdd(pParent->ctrl[4][nIndex].xyz, pParent->ctrl[0][nIndex].xyz, vTemp);
    VectorScale(vTemp, 0.5, vTemp);
    VectorCopy(pParent->ctrl[0][nIndex].xyz, p->ctrl[0][0].xyz);
                       VectorCopy(vTemp, p->ctrl[1][0].xyz);
    VectorCopy(pParent->ctrl[4][nIndex].xyz, p->ctrl[2][0].xyz);

    VectorCopy(pParent->ctrl[2][nIndex].xyz, p->ctrl[0][2].xyz);
    VectorCopy(pParent->ctrl[2][nIndex].xyz, p->ctrl[1][2].xyz);
    VectorCopy(pParent->ctrl[2][nIndex].xyz, p->ctrl[2][2].xyz);
    VectorCopy(pParent->ctrl[2][nIndex].xyz, p->ctrl[1][1].xyz);
    
    VectorCopy(pParent->ctrl[1][nIndex].xyz, p->ctrl[0][1].xyz);
    VectorCopy(pParent->ctrl[3][nIndex].xyz, p->ctrl[2][1].xyz);
  }
  else
  {
    VectorCopy(pParent->ctrl[0][nIndex].xyz, p->ctrl[0][0].xyz);
    VectorCopy(pParent->ctrl[1][nIndex].xyz, p->ctrl[1][0].xyz);
    VectorCopy(pParent->ctrl[2][nIndex].xyz, p->ctrl[2][0].xyz);
    VectorCopy(pParent->ctrl[3][nIndex].xyz, p->ctrl[3][0].xyz);
    VectorCopy(pParent->ctrl[4][nIndex].xyz, p->ctrl[4][0].xyz);
    
    VectorCopy(pParent->ctrl[1][nIndex].xyz, p->ctrl[0][1].xyz);
    VectorCopy(pParent->ctrl[1][nIndex].xyz, p->ctrl[1][1].xyz);
    VectorCopy(pParent->ctrl[2][nIndex].xyz, p->ctrl[2][1].xyz);
    VectorCopy(pParent->ctrl[3][nIndex].xyz, p->ctrl[3][1].xyz);
    VectorCopy(pParent->ctrl[3][nIndex].xyz, p->ctrl[4][1].xyz);

    VectorCopy(pParent->ctrl[1][nIndex].xyz, p->ctrl[0][2].xyz);
    VectorCopy(pParent->ctrl[1][nIndex].xyz, p->ctrl[1][2].xyz);
    VectorCopy(pParent->ctrl[2][nIndex].xyz, p->ctrl[2][2].xyz);
    VectorCopy(pParent->ctrl[3][nIndex].xyz, p->ctrl[3][2].xyz);
    VectorCopy(pParent->ctrl[3][nIndex].xyz, p->ctrl[4][2].xyz);
  }


  bool bEndCap = (nType == CCapDialog::ENDCAP || nType == CCapDialog::IENDCAP);
  if ((!bFirst && !bEndCap) || (bFirst && bEndCap))
  {
    drawVert_t vertTemp;
    for (i = 0; i < p->width; i++)
    {
      for (j = 0; j < p->height / 2; j++)
      {
        memcpy(&vertTemp, &p->ctrl[i][p->height - 1- j], sizeof (drawVert_t));
        memcpy(&p->ctrl[i][p->height - 1 - j], &p->ctrl[i][j], sizeof(drawVert_t));
        memcpy(&p->ctrl[i][j], &vertTemp, sizeof(drawVert_t));
      }
    }
  }

  //--Patch_CalcBounds(p, vMin, vMax);
  //--Brush_RebuildBrush(p->pSymbiot, vMin, vMax);
  Patch_Rebuild(p);
  Patch_CapTexture(p);
  return p->pSymbiot;
}


void Patch_CapCurrent(bool bInvertedBevel, bool bInvertedEndcap)
{
  patchMesh_t *pParent = NULL;
  brush_t *b[4];
  brush_t *pCap = NULL;
  b[0] = b[1] = b[2] = b[3] = NULL;
  int nIndex = 0;

    if (!QE_SingleBrush())
  {
    Sys_Printf("Cannot cap multiple selection. Please select a single patch.\n");
        return;
  }


    for (brush_t *pb = selected_brushes.next ; pb != NULL && pb != &selected_brushes ; pb = pb->next)
    {
    if (pb->patchBrush)
    {
      pParent = pb->pPatch;
      // decide which if any ends we are going to cap
      // if any of these compares hit, it is a closed patch and as such
      // the generic capping will work.. if we do not find a closed edge 
      // then we need to ask which kind of cap to add
      if (VectorCompare(pParent->ctrl[0][0].xyz, pParent->ctrl[pParent->width-1][0].xyz))
      {
        pCap = Cap(pParent, true, false);
        if (pCap != NULL)
        {
          b[nIndex++] = pCap;
        }
      }
      if (VectorCompare(pParent->ctrl[0][pParent->height-1].xyz, pParent->ctrl[pParent->width-1][pParent->height-1].xyz))
      {
        pCap = Cap(pParent, true, true);
        if (pCap != NULL)
        {
          b[nIndex++] = pCap;
        }
      }
      if (VectorCompare(pParent->ctrl[0][0].xyz, pParent->ctrl[0][pParent->height-1].xyz))
      {
        pCap = Cap(pParent, false, false);
        if (pCap != NULL)
        {
          b[nIndex++] = pCap;
        }
      }
      if (VectorCompare(pParent->ctrl[pParent->width-1][0].xyz, pParent->ctrl[pParent->width-1][pParent->height-1].xyz))
      {
        pCap = Cap(pParent, false, true);
        if (pCap != NULL)
        {
          b[nIndex++] = pCap;
        }
      }
    }
  }

  if (pParent)
  {
    // if we did not cap anything with the above tests
    if (nIndex == 0)
    {
      CCapDialog dlg;
      if (dlg.DoModal() == IDOK)
      {
        b[nIndex++] = CapSpecial(pParent, dlg.getCapType(), false);
        b[nIndex++] = CapSpecial(pParent, dlg.getCapType(), true);
      }
    }

    if (nIndex > 0)
    {
      while (nIndex > 0)
      {
        nIndex--;
        if (b[nIndex])
        {
          Select_Brush(b[nIndex]);
        }
      }
      eclass_t *pecNew = Eclass_ForName("func_group", false);
      if (pecNew)
      {
        entity_t *e = Entity_Create(pecNew);
        SetKeyValue(e, "type", "patchCapped");
      }
    }
  }
}


//FIXME: Table drive all this crap
//
void GenerateEndCaps(brush_t *brushParent, bool bBevel, bool bEndcap, bool bInverted)
{
  brush_t *b, *b2;
  patchMesh_t *p, *p2, *pParent;
  vec3_t vTemp, vMin, vMax;
  int i, j;

  pParent = brushParent->pPatch;

  Patch_CalcBounds(pParent, vMin, vMax);
  // basically generate two endcaps, place them, and link the three brushes with a func_group

  if (pParent->width > 9)
    b = Patch_GenericMesh(5, 3, 2, false);
  else
    b = Patch_GenericMesh(3, 3, 2, false);
  p = b->pPatch;

  vMin[0] = vMin[1] = vMin[2] = 9999;
  vMax[0] = vMax[1] = vMax[2] = -9999;

  for (i = 0; i < pParent->width; i++)
  {
    VectorCopy(pParent->ctrl[i][0].xyz, p->ctrl[Index3By[i][0]][Index3By[i][1]].xyz);
    for (j = 0; j < 3; j++)
    {
      if (pParent->ctrl[i][0].