/*
* Descent 3
* Copyright (C) 2024 Parallax Software
*
* This program 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 3 of the License, or
* (at your option) any later version.
*
* This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.

--- HISTORICAL COMMENTS FOLLOW ---

 * $Logfile: /DescentIII/Main/editor/HTexture.cpp $
 * $Revision: 1.1.1.1 $
 * $Date: 2003-08-26 03:57:38 $
 * $Author: kevinb $
 *
 * HTexture implementation
 *
 * $Log: not supported by cvs2svn $
 *
 * 37    12/27/99 8:26a Gwar
 *
 * 36    8/30/99 12:55p Gwar
 * added a parameter to HTexturePropagateToFace to not change the texture
 * of the target face
 *
 * 35    7/30/99 1:19p Gwar
 * don't set World_changed in NEWEDITOR
 *
 * 34    7/24/99 5:25a Gwar
 * NEWEDITOR changes to HTextureApplyToRoomFace
 *
 * 33    7/04/99 4:56p Gwar
 * changes for texture management in NEWEDITOR
 *
 * 32    5/19/99 12:19a Gwar
 * #define Curroomp, Curface, etc as members of prim struct in NEWEDITOR
 * -- this allows the main room frame and level window to share these
 * variables and makes them non-global (i.e. no more sync problem between
 * world and room views)
 *
 * 31    5/03/99 2:06a Gwar
 * added HTexture.cpp to project
 *
 * 30    1/20/99 10:50a Jason
 * added new terrain
 *
 * 29    10/21/98 1:27p Jason
 * fixed texture u2,v2 sliding problems
 *
 * 28    8/16/98 4:24p Matt
 * When copying UVs from one face to another, only copy u & v, and not
 * other fields in the uv structure.
 *
 * 27    8/15/98 5:04p Matt
 * Added code to copy a texture & UVs from one face to another
 *
 * 26    6/15/98 4:00p Jason
 * replaced monochromatic polymodel lighting with rgb lighting
 *
 * 25    4/16/98 10:42a Matt
 * Made texture propagation work across rooms.
 *
 * 24    4/02/98 12:23p Jason
 * trimmed some fat from our structures
 *
 * 23    9/23/97 12:20p Jason
 * fixed bug where rotating a texture would cause alphas and u2,v2s to
 * become corrupt
 *
 * 22    9/17/97 1:36p Samir
 * Fixed some new prototypes.
 *
 * 21    9/17/97 11:57a Matt
 * Ripped out segment code
 *
 * 19    8/21/97 6:01p Matt
 * Use groovy new FindSharedEdge() function
 *
 * 18    8/13/97 9:52a Matt
 * Combined slide left/right/up/down into one function, and the same with
 * rotate left/right
 *
 * 17    8/07/97 5:06p Jason
 * added new tiling system for terrain
 *
 * 16    8/07/97 3:19p Jason
 * replaced old terrain tmap system with new one
 *
 * 15    8/01/97 4:53p Jason
 * made a more general PropagateTextureToFace function call
 *
 * 14    7/22/97 7:08p Matt
 * Cleaned up D3EditState, moving some vars in and some out, and renaming
 * and changing a few others
 *
 * 13    7/18/97 7:38p Jason
 * finished room/terrain texture modifications
 *
 * 12    7/16/97 6:31p Jason
 * changed defaut texture uvs for terrain
 *
 * 15    6/24/97 12:41p Jason
 * checked in for safety
 *
 * 14    6/18/97 11:14a Mark
 * FROM JASON:Fixed dumb terrain rotational bug
 *
 * 13    6/17/97 4:16p Jason
 * added some terrain features
 *
 * 12    6/17/97 11:35a Jason
 * checked in for safety
 *
 * 11    6/06/97 4:57p Jason
 * more nifty megacell/tmap2 features
 *
 * 10    6/04/97 1:32p Matt
 * Changed Side_to_verts[] and Side_opposite[] to be arrays of ints, which
 * should be faster than bytes.
 *
 * 9     5/30/97 3:32p Samir
 * When rotating textures, lighting preserved
 *
 * 8     5/02/97 7:21p Matt
 * Added code to rotate tmap2's
 *
 * 7     4/17/97 4:03p Samir
 * Apply Tmap 1 and Tmap2 implemented, but no Tmap2 rendering is occurring
 * yet.
 *
 * 6     3/31/97 5:58p Matt
 * Revamped mine update flags
 *
 * 5     3/31/97 3:50p Samir
 * Set default texture uvs should work for side not whole segment.
 *
 * 4     2/26/97 6:40p Samir
 * changed g3s_uvl to g3UVL
 *
 * 3     2/26/97 3:59p Samir
 * Most scaling, rotating, sliding and flipping work.
 *
 * 2     2/20/97 11:59a Samir
 * Fixed bugs
 *
 * 1     2/20/97 11:50a Samir
 *
 * $NoKeywords: $
 */

#include "HTexture.h"

#ifndef NEWEDITOR
#include "d3edit.h"
#endif

#include "roomuvs.h"
#include "gametexture.h"
#include "terrain.h"
#include "room.h"
#include "descent.h"
#include "erooms.h"

#define HTEX_CALIB_VAL ((float)(1.0 / 128.0))

//	---------------------------------------------------------------------------
//	internal function prototypes
//	---------------------------------------------------------------------------

void HTextureRoomStretch(room *rp, int facenum, int edge, int direction);
void HTextureRotUVPoint(g3UVL *uvrot, float *rotmat, roomUVL *uv, g3UVL *uvcenter);
void HTextureCreate2DRotMat(float *rotmat, angle ang);
void HTextureRotUVTerrainPoint(g3UVL *uvrot, float *rotmat, g3UVL *uv, g3UVL *uvcenter);
void GetUVLForRoomPoint(int roomnum, int facenum, int vertnum, roomUVL *uvl);
int HTextureGetTopVertexForFace(int roomnum, int facenum);
int HTextureGetBottomVertexForFace(int roomnum, int facenum);
int HTextureGetLeftVertexForFace(int roomnum, int facenum);
int HTextureGetRightVertexForFace(int roomnum, int facenum);
void HTextureRotUVPointsOnRoomFace(room *roomp, int facenum, float *rotmat, g3UVL *uvcenter);
void HTextureComputeUVRoomFaceCenter(g3UVL *uvcenter, room *roomp, int facenum);
void HTextureTerrainStretch(int edge, int direction);

//	---------------------------------------------------------------------------
//	Functions to manipulate textures within the mine, through segments
//	---------------------------------------------------------------------------

// Apply the specified texture to the specified room:face
void HTextureApplyToRoomFace(room *rp, int facenum, int tnum) {
  ASSERT(rp->used);

#ifdef NEWEDITOR
  if (tnum == -1)
    return;
  if (rp->faces[facenum].tmap >= 0)
    SwitchTexture(rp, rp->faces[facenum].tmap, tnum);
#endif

  rp->faces[facenum].tmap = tnum;
}

// Copy texture from current face to adjacent face, tiling the UV coordinates
// Parameters:	destrp,destface - room:face that the propagate is based on
//					srcrp,srcface - room:face that is changed
// Return:	1 if success, 0 if faces not adjacent
int HTexturePropagateToFace(room *destrp, int destface, room *srcrp, int srcface, bool tex) {
  face *dfp = &destrp->faces[destface];
  face *sfp = &srcrp->faces[srcface];
  int v0, v1;

  // Get shared edge
  if (destrp != srcrp) { // Faces in different rooms
    if (!FindSharedEdgeAcrossRooms(destrp, destface, srcrp, srcface, &v0, &v1))
      return 0;
  } else { // Faces in same room
    if (!FindSharedEdge(dfp, sfp, &v0, &v1))
      return 0;
  }

  if (tex) {
#ifdef NEWEDITOR
    SwitchTexture(destrp, dfp->tmap, sfp->tmap);
#endif

    // Copy texture from Curface
    dfp->tmap = sfp->tmap;
  }

  // Assign uvs from shared edge to rest of verts in face
  AssignUVsToFace(destrp, destface, &sfp->face_uvls[(v1 + 1) % sfp->num_verts], &sfp->face_uvls[v1], v0,
                  (v0 + 1) % dfp->num_verts);

  // Success
  return 1;
}

// Copy texture UVs from one face to another
// Parameters:	destrp,destface - room:face that is changed
//					srcrp,srcface - room:face to copy from
//					offset - vert 0 on source is assigned to vert offset on dest
// Return:	1 if success, 0 if faces don't have the same number of verts
int HTextureCopyUVsToFace(room *destrp, int destface, room *srcrp, int srcface, int offset) {
  face *dfp = &destrp->faces[destface];
  face *sfp = &srcrp->faces[srcface];

  // Make sure faces have the same number of vertices
  if (dfp->num_verts != sfp->num_verts)
    return 0;

  // Copy UV values
  for (int i = 0; i < dfp->num_verts; i++) {
    dfp->face_uvls[(i + offset) % dfp->num_verts].u = sfp->face_uvls[i].u;
    dfp->face_uvls[(i + offset) % dfp->num_verts].v = sfp->face_uvls[i].v;
  }

  // Success!
#ifndef NEWEDITOR
  World_changed = 1;
#endif
  return 1;
}

//	texture flipping

void HTextureFlipX() {
  int i;

  if (Editor_view_mode == VM_TERRAIN) {
    // terrain_segment oldseg;

    for (i = 0; i < TERRAIN_DEPTH * TERRAIN_WIDTH; i++) {
      if (TerrainSelected[i]) {
        /*oldseg=Terrain_seg[i];
        Terrain_seg[i].u[0]=oldseg.u[1];
        Terrain_seg[i].u[1]=oldseg.u[0];
        Terrain_seg[i].u[2]=oldseg.u[3];
        Terrain_seg[i].u[3]=oldseg.u[2];

        Terrain_seg[i].v[0]=oldseg.v[1];
        Terrain_seg[i].v[1]=oldseg.v[0];
        Terrain_seg[i].v[2]=oldseg.v[3];
        Terrain_seg[i].v[3]=oldseg.v[2];*/
      }
    }
  } else {
    ASSERT(Curroomp->used);

    for (int i = 0; i < Curroomp->faces[Curface].num_verts; i++)
      Curroomp->faces[Curface].face_uvls[i].u = 1 - Curroomp->faces[Curface].face_uvls[i].u;
  }

#ifndef NEWEDITOR
  World_changed = 1;
#endif
}

void HTextureFlipY() {
  int i;

  if (Editor_view_mode == VM_TERRAIN) {
    terrain_segment oldseg;

    for (i = 0; i < TERRAIN_DEPTH * TERRAIN_WIDTH; i++) {
      if (TerrainSelected[i]) {
        oldseg = Terrain_seg[i];
        /*Terrain_seg[i].v[0]=oldseg.v[3];
        Terrain_seg[i].v[1]=oldseg.v[2];
        Terrain_seg[i].v[2]=oldseg.v[1];
        Terrain_seg[i].v[3]=oldseg.v[0];

        Terrain_seg[i].u[0]=oldseg.u[3];
        Terrain_seg[i].u[1]=oldseg.u[2];
        Terrain_seg[i].u[2]=oldseg.u[1];
        Terrain_seg[i].u[3]=oldseg.u[0];*/
      }
    }
  } else {
    ASSERT(Curroomp->used);

    for (int i = 0; i < Curroomp->faces[Curface].num_verts; i++)
      Curroomp->faces[Curface].face_uvls[i].v = 1 - Curroomp->faces[Curface].face_uvls[i].v;
  }

#ifndef NEWEDITOR
  World_changed = 1;
#endif
}

void HTextureSlide(room *rp, int facenum, float right, float up) {
  ASSERT(rp != NULL);
  ASSERT(rp->used);

  if (Editor_view_mode == VM_TERRAIN) {
    /*int i;
    for (i=0;i<TERRAIN_DEPTH*TERRAIN_WIDTH;i++)
    {
            if (TerrainSelected[i])
            {
                    for (int t=0;t<4;t++)
                    {
                            float val=Terrain_UV_lookup[Terrain_seg[i].u[t]];

                            val+=(1.0/32.0);

                            Terrain_seg[i].u[t]=TerrainLookupUV(val);
                    }

            }

    }
    */
    return;

  } else { // mine
    for (int i = 0; i < rp->faces[facenum].num_verts; i++) {
      rp->faces[facenum].face_uvls[i].u -= right / 128.0f;
      rp->faces[facenum].face_uvls[i].v += up / 128.0f;
    }
  }

#ifndef NEWEDITOR
  World_changed = 1;
#endif
}

void HTextureRotate(room *roomp, int facenum, angle ang) {
  g3UVL uvcenter;
  float rotmat[4];

  HTextureCreate2DRotMat(rotmat, ang);

  if (Editor_view_mode == VM_TERRAIN && ang == 0x4000) {
    for (int i = 0; i < TERRAIN_WIDTH * TERRAIN_DEPTH; i++) {
      if (TerrainSelected[i]) {
        /*int f=(Terrain_seg[i].rotation_factor&0x0F);
        f++;
        f%=4;

        Terrain_seg[i].rotation_factor&=0xF0;
        Terrain_seg[i].rotation_factor|=(f);*/
      }
    }

    return;
  } else {
    HTextureComputeUVRoomFaceCenter(&uvcenter, roomp, facenum);
    HTextureRotUVPointsOnRoomFace(roomp, facenum, rotmat, &uvcenter);
  }

#ifndef NEWEDITOR
  World_changed = 1;
#endif
}

void HTextureStretchMore(room *rp, int face, int edge) {
  if (Editor_view_mode == VM_TERRAIN) {
    HTextureTerrainStretch(edge, 1 * D3EditState.texscale);
  } else {
    HTextureRoomStretch(rp, face, edge, 1 * D3EditState.texscale);
  }
}

void HTextureStretchLess(room *rp, int face, int edge) {
  if (Editor_view_mode == VM_TERRAIN) {
    HTextureTerrainStretch(edge, (-1 * D3EditState.texscale));
  } else {
    HTextureRoomStretch(rp, face, edge, (-1 * D3EditState.texscale));
  }
}

void HTextureSetDefault(room *rp, int face) {
  if (Editor_view_mode == VM_TERRAIN) {
    for (int i = 0; i < TERRAIN_WIDTH * TERRAIN_DEPTH; i++) {
      if (TerrainSelected[i]) {
        int index = Terrain_seg[i].texseg_index;
        Terrain_tex_seg[index].rotation = 0;
      }
    }
    World_changed = 1;
  } else if (Editor_view_mode == VM_ROOM) {
    //@@Stretch_scale_x = (float)1.0;
    //@@Stretch_scale_y = (float)1.0;

    for (int i = 0; i < rp->faces[face].num_verts; i++) {
      float saveu2 = rp->faces[face].face_uvls[i].u2;
      float savev2 = rp->faces[face].face_uvls[i].v2;

      GetUVLForRoomPoint(ROOMNUM(rp), face, i, &rp->faces[face].face_uvls[i]);

      rp->faces[face].face_uvls[i].u2 = saveu2;
      rp->faces[face].face_uvls[i].v2 = savev2;
    }
  } else {
    //@@Stretch_scale_x = (float)1.0;
    //@@Stretch_scale_y = (float)1.0;

    for (int i = 0; i < rp->faces[face].num_verts; i++) {
      float saveu2 = rp->faces[face].face_uvls[i].u2;
      float savev2 = rp->faces[face].face_uvls[i].v2;

      GetUVLForRoomPoint(ROOMNUM(rp), face, i, &rp->faces[face].face_uvls[i]);

      rp->faces[face].face_uvls[i].u2 = saveu2;
      rp->faces[face].face_uvls[i].v2 = savev2;
    }
  }

#ifndef NEWEDITOR
  World_changed = 1;
#endif
}

void HTextureNextEdge() {
  Curedge++;

  if (Editor_view_mode == VM_TERRAIN) {
    if (Curedge >= 4)
      Curedge = 0;
  } else // mine
  {
    if (Curedge >= Curroomp->faces[Curface].num_verts)
      Curedge = 0;
  }

  State_changed = 1;
}

//	---------------------------------------------------------------------------
//	functions used by HTexture operations
//	---------------------------------------------------------------------------

//	direction = -1 or 1 depending on direction
// Stretches all vertices towards or away from a given edge
// Depending on the geometry of the face, this can cause distortions
void HTextureRoomStretch(room *rp, int facenum, int edge, int direction) {
  int next_edge = (edge + 1) % rp->faces[facenum].num_verts;

  // find deltas
  float du = rp->faces[facenum].face_uvls[next_edge].u - rp->faces[facenum].face_uvls[edge].u;
  float dv = rp->faces[facenum].face_uvls[next_edge].v - rp->faces[facenum].face_uvls[edge].v;

  // rotate delta's 90 degrees
  float nu = -dv;
  float nv = du;

  // Find a magnitude to shift by
  float mag = sqrt((nv * nv) + (nu * nu));
  nv /= mag;
  nu /= mag;

  nv /= 64.0;
  nu /= 64.0;

  // Apply to all verts except for our edge
  for (int i = 0; i < rp->faces[facenum].num_verts; i++) {
    if (i == edge || i == next_edge)
      continue;

    rp->faces[facenum].face_uvls[i].v -= (nv * direction);
    rp->faces[facenum].face_uvls[i].u -= (nu * direction);
  }

#ifndef NEWEDITOR
  World_changed = 1;
#endif
}

void HTextureTerrainStretch(int edge, int direction) {
  int i;

  for (i = 0; i < TERRAIN_WIDTH * TERRAIN_DEPTH; i++) {
    if (TerrainSelected[i]) {
    }
  }

#ifndef NEWEDITOR
  World_changed = 1;
#endif
}

void HTextureComputeUVRoomFaceCenter(g3UVL *uvcenter, room *roomp, int facenum) {
  int i;
  face *facep = &roomp->faces[facenum];

  uvcenter->u = 0;
  uvcenter->v = 0;

  for (i = 0; i < facep->num_verts; i++) {
    uvcenter->u += facep->face_uvls[i].u;
    uvcenter->v += facep->face_uvls[i].v;
  }

  uvcenter->u /= i;
  uvcenter->v /= i;
}

void HTextureRotUVPoint(g3UVL *uvrot, float *rotmat, roomUVL *uv, g3UVL *uvcenter) {
  uvrot->u = ((uv->u - uvcenter->u) * rotmat[0]) + ((uv->v - uvcenter->v) * rotmat[1]) + uvcenter->u;
  uvrot->v = ((uv->u - uvcenter->u) * rotmat[2]) + ((uv->v - uvcenter->v) * rotmat[3]) + uvcenter->v;
}

void HTextureRotUVPointsOnRoomFace(room *roomp, int facenum, float *rotmat, g3UVL *uvcenter) {
  int v;
  face *facep = &roomp->faces[facenum];
  g3UVL tuv;

  for (v = 0; v < facep->num_verts; v++) {
    HTextureRotUVPoint(&tuv, rotmat, &facep->face_uvls[v], uvcenter);
    facep->face_uvls[v].u = tuv.u;
    facep->face_uvls[v].v = tuv.v;
  }
}

void HTextureCreate2DRotMat(float *rotmat, angle ang) {
  float sinang, cosang;

  sinang = FixSin(ang);
  cosang = FixCos(ang);

  rotmat[0] = cosang;
  rotmat[1] = sinang;
  rotmat[2] = -sinang;
  rotmat[3] = cosang;
}

void HTextureRotUVTerrainPoint(g3UVL *uvrot, float *rotmat, g3UVL *uv, g3UVL *uvcenter) {
  uvrot->u = ((uv->u - uvcenter->u) * rotmat[0]) + ((uv->v - uvcenter->v) * rotmat[1]) + uvcenter->u;
  uvrot->v = ((uv->u - uvcenter->u) * rotmat[2]) + ((uv->v - uvcenter->v) * rotmat[3]) + uvcenter->v;
}

// returns the index in the face_verts array for the leftmost point on this face
int HTextureGetLeftVertexForFace(int roomnum, int facenum) {
  matrix face_matrix, trans_matrix;
  vector fvec;
  vector avg_vert;
  vector verts[MAX_VERTS_PER_FACE];

  ASSERT(Rooms[roomnum].used);
  ASSERT(Rooms[roomnum].faces[facenum].num_verts >= 3);

  // find the center point of this face
  vm_MakeZero(&avg_vert);
  for (int i = 0; i < Rooms[roomnum].faces[facenum].num_verts; i++)
    avg_vert += Rooms[roomnum].verts[Rooms[roomnum].faces[facenum].face_verts[i]];

  avg_vert /= i;

  // Make the orientation matrix
  fvec = Rooms[roomnum].faces[facenum].normal;

  vm_VectorToMatrix(&face_matrix, &fvec, NULL, NULL);
  // Make the transformation matrix

  angvec avec;
  vm_ExtractAnglesFromMatrix(&avec, &face_matrix);
  vm_AnglesToMatrix(&trans_matrix, avec.p, avec.h, avec.b);

  // Rotate all the points
  for (i = 0; i < Rooms[roomnum].faces[facenum].num_verts; i++) {
    vector vert = Rooms[roomnum].verts[Rooms[roomnum].faces[facenum].face_verts[i]];
    vector rot_vert;

    vert -= avg_vert;
    vm_MatrixMulVector(&rot_vert, &vert, &trans_matrix);

    verts[i] = rot_vert;
  }

  // Find left most point
  int leftmost_point = -1;
  float leftmost_x = 900000.00f; // a big number

  for (i = 0; i < Rooms[roomnum].faces[facenum].num_verts; i++) {
    if (verts[i].x < leftmost_x) {
      leftmost_point = i;
      leftmost_x = verts[i].x;
    }
  }

  ASSERT(leftmost_point != -1);
  return leftmost_point;
}

// returns the index in the face_verts array for the topmost point on this face
int HTextureGetTopVertexForFace(int roomnum, int facenum) {
  matrix face_matrix, trans_matrix;
  vector fvec;
  vector avg_vert;
  vector verts[MAX_VERTS_PER_FACE];

  ASSERT(Rooms[roomnum].used);
  ASSERT(Rooms[roomnum].faces[facenum].num_verts >= 3);

  // find the center point of this face
  vm_MakeZero(&avg_vert);
  for (int i = 0; i < Rooms[roomnum].faces[facenum].num_verts; i++)
    avg_vert += Rooms[roomnum].verts[Rooms[roomnum].faces[facenum].face_verts[i]];

  avg_vert /= i;

  // Make the orientation matrix
  fvec = Rooms[roomnum].faces[facenum].normal;

  vm_VectorToMatrix(&face_matrix, &fvec, NULL, NULL);
  // Make the transformation matrix

  angvec avec;
  vm_ExtractAnglesFromMatrix(&avec, &face_matrix);
  vm_AnglesToMatrix(&trans_matrix, avec.p, avec.h, avec.b);

  // Rotate all the points
  for (i = 0; i < Rooms[roomnum].faces[facenum].num_verts; i++) {
    vector vert = Rooms[roomnum].verts[Rooms[roomnum].faces[facenum].face_verts[i]];
    vector rot_vert;

    vert -= avg_vert;
    vm_MatrixMulVector(&rot_vert, &vert, &trans_matrix);

    verts[i] = rot_vert;
  }

  // Find top most point
  int topmost_point = -1;
  float topmost_y = -900000.0f; // a big number

  for (i = 0; i < Rooms[roomnum].faces[facenum].num_verts; i++) {
    if (verts[i].y > topmost_y) {
      topmost_point = i;
      topmost_y = verts[i].y;
    }
  }

  ASSERT(topmost_point != -1);

  return topmost_point;
}

// returns the index in the face_verts array for the rightmost point on this face
int HTextureGetRightVertexForFace(int roomnum, int facenum) {
  matrix face_matrix, trans_matrix;
  vector fvec;
  vector avg_vert;
  vector verts[MAX_VERTS_PER_FACE];

  ASSERT(Rooms[roomnum].used);
  ASSERT(Rooms[roomnum].faces[facenum].num_verts >= 3);

  // find the center point of this face
  vm_MakeZero(&avg_vert);
  for (int i = 0; i < Rooms[roomnum].faces[facenum].num_verts; i++)
    avg_vert += Rooms[roomnum].verts[Rooms[roomnum].faces[facenum].face_verts[i]];

  avg_vert /= i;

  // Make the orientation matrix
  fvec = Rooms[roomnum].faces[facenum].normal;

  vm_VectorToMatrix(&face_matrix, &fvec, NULL, NULL);
  // Make the transformation matrix

  angvec avec;
  vm_ExtractAnglesFromMatrix(&avec, &face_matrix);
  vm_AnglesToMatrix(&trans_matrix, avec.p, avec.h, avec.b);

  // Rotate all the points
  for (i = 0; i < Rooms[roomnum].faces[facenum].num_verts; i++) {
    vector vert = Rooms[roomnum].verts[Rooms[roomnum].faces[facenum].face_verts[i]];
    vector rot_vert;

    vert -= avg_vert;
    vm_MatrixMulVector(&rot_vert, &vert, &trans_matrix);

    verts[i] = rot_vert;
  }

  // Find right most point
  int rightmost_point = -1;
  float rightmost_x = -900000.00f; // a big number

  for (i = 0; i < Rooms[roomnum].faces[facenum].num_verts; i++) {
    if (verts[i].x > rightmost_x) {
      rightmost_point = i;
      rightmost_x = verts[i].x;
    }
  }

  ASSERT(rightmost_point != -1);
  return rightmost_point;
}

// returns the index in the face_verts array for the most point on this face
int HTextureGetBottomVertexForFace(int roomnum, int facenum) {
  matrix face_matrix, trans_matrix;
  vector fvec;
  vector avg_vert;
  vector verts[MAX_VERTS_PER_FACE];

  ASSERT(Rooms[roomnum].used);
  ASSERT(Rooms[roomnum].faces[facenum].num_verts >= 3);

  // find the center point of this face
  vm_MakeZero(&avg_vert);
  for (int i = 0; i < Rooms[roomnum].faces[facenum].num_verts; i++)
    avg_vert += Rooms[roomnum].verts[Rooms[roomnum].faces[facenum].face_verts[i]];

  avg_vert /= i;

  // Make the orientation matrix
  fvec = Rooms[roomnum].faces[facenum].normal;

  vm_VectorToMatrix(&face_matrix, &fvec, NULL, NULL);
  // Make the transformation matrix

  angvec avec;
  vm_ExtractAnglesFromMatrix(&avec, &face_matrix);
  vm_AnglesToMatrix(&trans_matrix, avec.p, avec.h, avec.b);

  // Rotate all the points
  for (i = 0; i < Rooms[roomnum].faces[facenum].num_verts; i++) {
    vector vert = Rooms[roomnum].verts[Rooms[roomnum].faces[facenum].face_verts[i]];
    vector rot_vert;

    vert -= avg_vert;
    vm_MatrixMulVector(&rot_vert, &vert, &trans_matrix);

    verts[i] = rot_vert;
  }

  // Find bottom most point
  int bottommost_point = -1;
  float bottommost_y = 900000.0f; // a big number

  for (i = 0; i < Rooms[roomnum].faces[facenum].num_verts; i++) {
    if (verts[i].y < bottommost_y) {
      bottommost_point = i;
      bottommost_y = verts[i].y;
    }
  }

  ASSERT(bottommost_point != -1);

  return bottommost_point;
}

/*void HTextureGetBoxUVLForFace (room *rp,facenum)
{
        int l,r,t,b;
        vector lpoint,rpoint,tpoint,bpoint;
        g3UVL luvl,ruvl,tuvl,buvl,xchange,ychange;

        b=HTextureGetBottomVertexForFace (roomnum,facenum);
        t=HTextureGetTopVertexForFace (roomnum,facenum);
        l=HTextureGetLeftVertexForFace (roomnum,facenum);
        r=HTextureGetRightVertexForFace (roomnum,facenum);

        lpoint=rp->verts[rp->faces[facenum].face_verts[l]];
        rpoint=rp->verts[rp->faces[facenum].face_verts[r]];
        tpoint=rp->verts[rp->faces[facenum].face_verts[t]];
        bpoint=rp->verts[rp->faces[facenum].face_verts[b]];

        luvl=rp->faces[facenum].face_uvls[l];
        ruvl=rp->faces[facenum].face_uvls[r];
        tuvl=rp->faces[facenum].face_uvls[t];
        buvl=rp->faces[facenum].face_uvls[b];

        xchange.u=ruvl.u-luvl.u;
        xchange.v=ruvl.v-luvl.v;

        ychange=buvl.u-tuvl.u;
        ychange=buvl.v-tuvl.v;

}*/