Descent3/editor/editor_lighting.cpp

/*
* 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/editor_lighting.cpp $
 * $Revision: 1.1.1.1 $
 * $Date: 2003-08-26 03:57:38 $
 * $Author: kevinb $
 * $NoKeywords: $
 */

#include <algorithm>
#include <windows.h>
#include "3d.h"
#include "gametexture.h"
#include "erooms.h"
#include "editor_lighting.h"
#include "descent.h"
#include "room.h"
#include "lightmap.h"
#include "polymodel.h"
#include <string.h>
#include <stdlib.h>
#include "terrain.h"
#include "radiosity.h"
#include "lighting.h"
#include "findintersection.h"
#include "lightmap_info.h"
#include "object_lighting.h"
#include "d3edit.h"
#include "ddio.h"
#include "bsp.h"
#include "Application.h"
#include "AppDatabase.h"
#include "loadlevel.h"
#include "special_face.h"
#include "boa.h"
#include "mem.h"
#include "mono.h"

struct spec_vertex {
  float x, y;
};

int AllowCombining = 1;
float GlobalMultiplier = 1.0;

rad_surface *Light_surfaces = NULL;

vector ScratchCenters[MAX_LIGHTMAP_INFOS];
vector ScratchRVecs[MAX_LIGHTMAP_INFOS];
vector ScratchUVecs[MAX_LIGHTMAP_INFOS];

float Room_multiplier[MAX_ROOMS + MAX_PALETTE_ROOMS];
float Room_ambience_r[MAX_ROOMS + MAX_PALETTE_ROOMS], Room_ambience_g[MAX_ROOMS + MAX_PALETTE_ROOMS],
    Room_ambience_b[MAX_ROOMS + MAX_PALETTE_ROOMS];

uint8_t *TerrainLightSpeedup[MAX_SATELLITES];

int LightSpacing = LIGHTMAP_SPACING;
int BestFit = 0;
int Square_surfaces = 0;
int Lightmaps_for_rad = 0;

// Ambient values for terrain
float Ambient_red = 0.0f, Ambient_green = 0.0f, Ambient_blue = 0.0f;

void DoTerrainDynamicTable();

uint8_t *Lightmap_mask = NULL;
static uint8_t *Lmi_spoken_for;
int Squeeze_lightmap_handle = -1;

int FindEmptyMaskSpot(int w, int h, int *dest_x, int *dest_y) {
  int cur_x = 0, cur_y = 0;
  int i, t;

  for (cur_y = 0; cur_y < 128; cur_y++) {
    if (cur_y + h > 128)
      return 0;
    for (cur_x = 0; cur_x < 128; cur_x++) {
      if (cur_x + w > 128)
        continue;

      int hit_mask = 0;
      for (i = 0; i < h && !hit_mask; i++) {
        for (t = 0; t < w && !hit_mask; t++) {
          if (Lightmap_mask[((cur_y + i) * 128) + cur_x + t])
            hit_mask = 1;
        }
      }
      if (hit_mask == 0) {
        // Hurray! We found an empty spot
        *dest_x = cur_x;
        *dest_y = cur_y;
        return 1;
      }
    }
  }

  return 0;
}

void CopySqueezeBodyAndEdges(uint16_t *dest_data, uint16_t *src_data, int w, int h, int dest_x, int dest_y) {
  int i, t;

  ASSERT(w + dest_x <= 126);
  ASSERT(h + dest_y <= 126);
  ASSERT(dest_x >= 0 && dest_y >= 0);

  // First copy the main body
  for (i = 0; i < h; i++) {
    for (t = 0; t < w; t++) {
      dest_data[((dest_y + 1 + i) * 128) + (dest_x + 1 + t)] = src_data[(w * i) + t];
      Lightmap_mask[((dest_y + i + 1) * 128) + dest_x + 1 + t] = 1;
    }
  }

  // Now copy the edges
  // Left edge
  for (i = 0; i < h; i++) {
    dest_data[((dest_y + 1 + i) * 128) + (dest_x + 0)] = src_data[(w * i) + 0];
    Lightmap_mask[((dest_y + i + 1) * 128) + dest_x + 0] = 1;
  }
  // Right edge
  for (i = 0; i < h; i++) {
    dest_data[((dest_y + 1 + i) * 128) + (dest_x + w + 1)] = src_data[(w * i) + (w - 1)];
    Lightmap_mask[((dest_y + i + 1) * 128) + dest_x + w + 1] = 1;
  }
  // Top edge
  for (i = 0; i < w; i++) {
    dest_data[(dest_y * 128) + (dest_x + i + 1)] = src_data[i];
    Lightmap_mask[(dest_y * 128) + (dest_x + i + 1)] = 1;
  }
  // Bottom edge
  for (i = 0; i < w; i++) {
    dest_data[((dest_y + 1 + h) * 128) + (dest_x + i + 1)] = src_data[(w * (h - 1)) + i];
    Lightmap_mask[((dest_y + 1 + h) * 128) + (dest_x + i + 1)] = 1;
  }

  // Now copy the corners
  // Upper left
  dest_data[(dest_y * 128) + (dest_x)] = src_data[0];
  Lightmap_mask[(dest_y * 128) + (dest_x)] = 1;
  // Upper right
  dest_data[(dest_y * 128) + (dest_x + w + 1)] = src_data[w - 1];
  Lightmap_mask[(dest_y * 128) + (dest_x + w + 1)] = 1;
  // Lower left
  dest_data[((dest_y + h + 1) * 128) + (dest_x)] = src_data[w * (h - 1)];
  Lightmap_mask[((dest_y + h + 1) * 128) + (dest_x)] = 1;
  // Lower right
  dest_data[((dest_y + h + 1) * 128) + (dest_x + w + 1)] = src_data[(w * (h - 1)) + (w - 1)];
  Lightmap_mask[((dest_y + h + 1) * 128) + (dest_x + w + 1)] = 1;
}

void CopySqueezeDataForRooms(int roomnum, int facenum, uint16_t *dest_data, int dest_x, int dest_y) {
  room *rp = &Rooms[roomnum];
  lightmap_info *lmi_ptr = &LightmapInfo[rp->faces[facenum].lmi_handle];
  uint16_t *src_data = (uint16_t *)lm_data(lmi_ptr->lm_handle);

  int w = lmi_ptr->width;
  int h = lmi_ptr->height;

  // Copy over the actual lightmap data
  CopySqueezeBodyAndEdges(dest_data, src_data, w, h, dest_x, dest_y);

  // Now alter all face uvs that have this lightmap info
  float dest_u = (float)(dest_x + 1) / 128.0;
  float dest_v = (float)(dest_y + 1) / 128.0;

  float u_scalar = (float)w / 128.0;
  float v_scalar = (float)h / 128.0;

  for (int t = roomnum; t <= Highest_room_index; t++) {
    room *this_rp = &Rooms[t];
    if (!this_rp->used)
      continue;

    for (int j = 0; j < this_rp->num_faces; j++) {

      if (!(this_rp->faces[j].flags & FF_LIGHTMAP))
        continue;

      if (this_rp->faces[j].lmi_handle == BAD_LMI_INDEX)
        continue;

      if (Lmi_spoken_for[this_rp->faces[j].lmi_handle])
        continue;
      if (this_rp->faces[j].lmi_handle == rp->faces[facenum].lmi_handle) {
        lmi_ptr->x1 = dest_x + 1;
        lmi_ptr->y1 = dest_y + 1;

        // We have to alter our uvs for this face to reflect our change
        face *fp = &this_rp->faces[j];
        for (int k = 0; k < fp->num_verts; k++) {
          fp->face_uvls[k].u2 *= u_scalar;
          fp->face_uvls[k].u2 += dest_u;

          fp->face_uvls[k].v2 *= v_scalar;
          fp->face_uvls[k].v2 += dest_v;
        }
      }
    }
  }

  ASSERT(rp->faces[facenum].lmi_handle != BAD_LMI_INDEX);

  Lmi_spoken_for[rp->faces[facenum].lmi_handle] = 1;

  // Free our old lightmap
  GameLightmaps[lmi_ptr->lm_handle].used = 1;
  lm_FreeLightmap(lmi_ptr->lm_handle);

  lmi_ptr->lm_handle = Squeeze_lightmap_handle;
  GameLightmaps[Squeeze_lightmap_handle].used++;
}

void CopySqueezeDataForObject(object *obj, int subnum, int facenum, uint16_t *dest_data, int dest_x, int dest_y) {
  lightmap_object_face *fp = &obj->lm_object.lightmap_faces[subnum][facenum];
  lightmap_info *lmi_ptr = &LightmapInfo[fp->lmi_handle];
  uint16_t *src_data = (uint16_t *)lm_data(lmi_ptr->lm_handle);
  int t, k;

  int w = lmi_ptr->width;
  int h = lmi_ptr->height;

  // Copy over the actual lightmap data
  CopySqueezeBodyAndEdges(dest_data, src_data, w, h, dest_x, dest_y);

  // Now alter all face uvs that have this lightmap info
  float dest_u = (float)(dest_x + 1) / 128.0;
  float dest_v = (float)(dest_y + 1) / 128.0;

  float u_scalar = (float)w / 128.0;
  float v_scalar = (float)h / 128.0;

  for (int objnum = obj - Objects; objnum != -1; objnum = Objects[objnum].next) {
    object *this_obj = &Objects[objnum];

    if (this_obj->lighting_render_type != LRT_LIGHTMAPS)
      continue;
    if (!this_obj->lm_object.used)
      continue;

    for (t = 0; t < this_obj->lm_object.num_models; t++) {
      if (IsNonRenderableSubmodel(&Poly_models[this_obj->rtype.pobj_info.model_num], t))
        continue;

      for (k = 0; k < this_obj->lm_object.num_faces[t]; k++) {
        lightmap_object_face *this_fp = &this_obj->lm_object.lightmap_faces[t][k];
        int lmi_handle = this_fp->lmi_handle;
        if (lmi_handle == BAD_LMI_INDEX)
          continue;
        if (Lmi_spoken_for[lmi_handle])
          continue;

        if (lmi_handle == fp->lmi_handle) {
          lmi_ptr->x1 = dest_x + 1;
          lmi_ptr->y1 = dest_y + 1;

          // We have to alter our uvs for this face to reflect our change
          for (int j = 0; j < this_fp->num_verts; j++) {
            this_fp->u2[j] *= u_scalar;
            this_fp->u2[j] += dest_u;

            this_fp->v2[j] *= v_scalar;
            this_fp->v2[j] += dest_v;
          }
        }
      }
    }
  }

  ASSERT(fp->lmi_handle != BAD_LMI_INDEX);
  Lmi_spoken_for[fp->lmi_handle] = 1;

  // Free our old lightmap
  GameLightmaps[lmi_ptr->lm_handle].used = 1;
  lm_FreeLightmap(lmi_ptr->lm_handle);

  lmi_ptr->lm_handle = Squeeze_lightmap_handle;
  GameLightmaps[Squeeze_lightmap_handle].used++;
}

// Simply clears flags for combine portals
void ClearCombinePortals(int terrain) {
  for (int i = 0; i <= Highest_room_index; i++) {
    room *rp = &Rooms[i];

    if (!rp->used)
      continue;

    if (terrain && !(rp->flags & RF_EXTERNAL))
      continue;

    if (!terrain && (rp->flags & RF_EXTERNAL))
      continue;

    for (int t = 0; t < rp->num_portals; t++) {
      portal *portal_a = &rp->portals[t];
      portal_a->flags &= ~PF_COMBINED;
    }
  }
}

// For rendering...combines all portals if they are on the same plane
void CheckCombinePortals(int terrain) {
  ClearCombinePortals(terrain);

  int combine_count = 0;
  mprintf(0, "Combining portals...");

  for (int i = 0; i <= Highest_room_index; i++) {
    room *rp = &Rooms[i];

    if (!rp->used)
      continue;

    if (terrain && !(rp->flags & RF_EXTERNAL))
      continue;

    if (!terrain && (rp->flags & RF_EXTERNAL))
      continue;

    for (int t = 0; t < rp->num_portals; t++) {
      portal *portal_a = &rp->portals[t];
      face *face_a = &rp->faces[portal_a->portal_face];

      if (portal_a->flags & PF_COMBINED)
        continue;

      // Don't combine if face is breakable
      if (GameTextures[face_a->tmap].flags & TF_BREAKABLE)
        continue;

      float dist_a = vm_DotProduct(&rp->verts[face_a->face_verts[0]], &face_a->normal);

      for (int k = 0; k < rp->num_portals; k++) {
        portal *portal_b = &rp->portals[k];
        face *face_b = &rp->faces[portal_b->portal_face];

        if (portal_b->flags & PF_COMBINED)
          continue;

        // Don't combine if one portal is render-faces and the other is not
        if ((portal_a->flags & PF_RENDER_FACES) != (portal_b->flags & PF_RENDER_FACES))
          continue;

        // Don't combine if face is breakable
        if (GameTextures[face_b->tmap].flags & TF_BREAKABLE)
          continue;

        if (t == k)
          continue;

        // Check to see if the portals connect to the same room
        if (portal_a->croom != portal_b->croom)
          continue;

        /*// Check to see if they share a normal
        float dp=vm_DotProduct (&face_a->normal,&face_b->normal);

        if (dp < .95f)
                continue;


        // Check to see if the distances are same
        float dist_b=vm_DotProduct (&rp->verts[face_b->face_verts[0]],&face_b->normal);

        if (fabs(dist_b-dist_a)>.5)
                continue;

        int match=0;
        // Test to see if any points at all can touch
        for (int x=0; x<face_a->num_verts && !match; x++ )
        {
                for (int y=0; y<face_b->num_verts && !match; y++ )
                {
                        if (PointsAreSame(&rp->verts[face_a->face_verts[x]],&rp->verts[face_b->face_verts[y]]))
                                match=1;
                }
        }

        if (match==0)
                continue;

        //Check to see if the portals connect to the same room
        if (portal_a->croom != portal_b->croom)
                continue;

        // Hurray! These portals can be combined*/
        portal_a->flags |= PF_COMBINED;
        portal_b->flags |= PF_COMBINED;

        portal_a->combine_master = t;
        portal_b->combine_master = t;
        combine_count++;
      }
    }
  }

  mprintf(0, "%d portals combined.\n", combine_count);
}

// Squeezes all the lightmaps down into as few 128x128s as possible
void SqueezeLightmaps(int external, int target_roomnum) {
  int i, t, k;
  mprintf(0, "Squeezing %s lightmaps, please wait...\n", external ? "external" : "internal");

  Lmi_spoken_for = mem_rmalloc<uint8_t>(MAX_LIGHTMAP_INFOS);
  Lightmap_mask = (uint8_t *)mem_malloc(128 * 128);
  Squeeze_lightmap_handle = -1;

  ASSERT(Lightmap_mask);
  ASSERT(Lmi_spoken_for);
  memset(Lmi_spoken_for, 0, MAX_LIGHTMAP_INFOS);
  memset(Lightmap_mask, 0, 128 * 128);

  // Go through all the rooms and sqeeze them one by one
  for (i = 0; i <= Highest_room_index; i++) {
    room *rp = &Rooms[i];
    if (!rp->used)
      continue;
    if (rp->flags & RF_NO_LIGHT)
      continue;

    if (external) {
      if (!(rp->flags & RF_EXTERNAL))
        continue;
    } else {
      if ((rp->flags & RF_EXTERNAL))
        continue;

      if (target_roomnum != -1 && target_roomnum != i)
        continue;
    }

    // Go through each face
    for (t = 0; t < rp->num_faces; t++) {
      face *fp = &rp->faces[t];
      int lmi_handle = fp->lmi_handle;

      if (!(fp->flags & FF_LIGHTMAP))
        continue;

      if (lmi_handle == BAD_LMI_INDEX)
        continue;
      if (Lmi_spoken_for[lmi_handle])
        continue;

      lightmap_info *lmi = &LightmapInfo[lmi_handle];

      int dest_x, dest_y;
      int src_w = lmi->width;
      int src_h = lmi->height;

      if (Squeeze_lightmap_handle == -1) {
        memset(Lightmap_mask, 0, 128 * 128);
        Squeeze_lightmap_handle = lm_AllocLightmap(128, 128);
        uint16_t *fill_data = (uint16_t *)lm_data(Squeeze_lightmap_handle);
        memset(fill_data, 0, 128 * 128 * 2);
      }

      if (FindEmptyMaskSpot(src_w + 2, src_h + 2, &dest_x, &dest_y)) {
        // Cool, found a spot
        CopySqueezeDataForRooms(i, t, lm_data(Squeeze_lightmap_handle), dest_x, dest_y);
      } else {
        // Can't find an empty slot, so search through all the other remaining faces
        for (k = t; k < rp->num_faces; k++) {
          face *fp = &rp->faces[k];
          int lmi_handle = fp->lmi_handle;

          if (!(fp->flags & FF_LIGHTMAP))
            continue;
          if (lmi_handle == BAD_LMI_INDEX)
            continue;
          if (Lmi_spoken_for[lmi_handle])
            continue;

          lightmap_info *lmi = &LightmapInfo[lmi_handle];

          int src_w = lmi->width;
          int src_h = lmi->height;

          if (FindEmptyMaskSpot(src_w + 2, src_h + 2, &dest_x, &dest_y)) {
            CopySqueezeDataForRooms(i, k, lm_data(Squeeze_lightmap_handle), dest_x, dest_y);
          }
        }

        // Now, allocate a new lightmap and start over
        ASSERT(Squeeze_lightmap_handle != -1);
        ASSERT(GameLightmaps[Squeeze_lightmap_handle].used != 1);
        GameLightmaps[Squeeze_lightmap_handle].used--;

        memset(Lightmap_mask, 0, 128 * 128);
        Squeeze_lightmap_handle = lm_AllocLightmap(128, 128);
        uint16_t *fill_data = (uint16_t *)lm_data(Squeeze_lightmap_handle);
        memset(fill_data, 0, 128 * 128 * 2);

        ASSERT(Lmi_spoken_for[lmi_handle] == 0);

        if (FindEmptyMaskSpot(src_w + 2, src_h + 2, &dest_x, &dest_y)) {
          CopySqueezeDataForRooms(i, t, lm_data(Squeeze_lightmap_handle), dest_x, dest_y);
        } else {
          Int3(); // Get Jason, how did this happen????
        }
      }
    }

    // Now search through all the objects in this room
    for (k = rp->objects; k != -1; k = Objects[k].next) {
      object *obj = &Objects[k];
      if (obj->lighting_render_type != LRT_LIGHTMAPS)
        continue;
      if (!obj->lm_object.used)
        continue;

      for (t = 0; t < obj->lm_object.num_models; t++) {
        if (IsNonRenderableSubmodel(&Poly_models[obj->rtype.pobj_info.model_num], t))
          continue;

        for (int j = 0; j < obj->lm_object.num_faces[t]; j++) {
          lightmap_object_face *fp = &obj->lm_object.lightmap_faces[t][j];
          int lmi_handle = fp->lmi_handle;
          if (lmi_handle == BAD_LMI_INDEX)
            continue;
          if (Lmi_spoken_for[lmi_handle])
            continue;

          lightmap_info *lmi = &LightmapInfo[lmi_handle];

          int dest_x, dest_y;
          int src_w = lmi->width;
          int src_h = lmi->height;

          if (Squeeze_lightmap_handle == -1) {
            memset(Lightmap_mask, 0, 128 * 128);
            Squeeze_lightmap_handle = lm_AllocLightmap(128, 128);
            uint16_t *fill_data = (uint16_t *)lm_data(Squeeze_lightmap_handle);
            memset(fill_data, 0, 128 * 128 * 2);
          }

          if (FindEmptyMaskSpot(src_w + 2, src_h + 2, &dest_x, &dest_y)) {
            // Cool, found a spot
            CopySqueezeDataForObject(obj, t, j, lm_data(Squeeze_lightmap_handle), dest_x, dest_y);
          } else {
            // Can't find an empty slot, so search through all the other remaining faces
            for (int a = rp->objects; a != -1; a = Objects[a].next) {
              object *obj = &Objects[a];
              if (obj->lighting_render_type != LRT_LIGHTMAPS)
                continue;
              if (!obj->lm_object.used)
                continue;

              for (int b = 0; b < obj->lm_object.num_models; b++) {
                if (IsNonRenderableSubmodel(&Poly_models[obj->rtype.pobj_info.model_num], b))
                  continue;

                for (int c = 0; c < obj->lm_object.num_faces[b]; c++) {
                  lightmap_object_face *fp = &obj->lm_object.lightmap_faces[b][c];
                  int lmi_handle = fp->lmi_handle;
                  if (lmi_handle == BAD_LMI_INDEX)
                    continue;
                  if (Lmi_spoken_for[lmi_handle])
                    continue;

                  lightmap_info *lmi = &LightmapInfo[lmi_handle];

                  int src_w = lmi->width;
                  int src_h = lmi->height;

                  if (FindEmptyMaskSpot(src_w + 2, src_h + 2, &dest_x, &dest_y)) {
                    CopySqueezeDataForObject(obj, b, c, lm_data(Squeeze_lightmap_handle), dest_x, dest_y);
                  }
                }
              }
            }

            // Now, allocate a new lightmap and start over
            ASSERT(Squeeze_lightmap_handle != -1);
            ASSERT(GameLightmaps[Squeeze_lightmap_handle].used != 1);
            GameLightmaps[Squeeze_lightmap_handle].used--;

            memset(Lightmap_mask, 0, 128 * 128);
            Squeeze_lightmap_handle = lm_AllocLightmap(128, 128);
            uint16_t *fill_data = (uint16_t *)lm_data(Squeeze_lightmap_handle);
            memset(fill_data, 0, 128 * 128 * 2);

            ASSERT(Lmi_spoken_for[lmi_handle] == 0);

            if (FindEmptyMaskSpot(src_w + 2, src_h + 2, &dest_x, &dest_y)) {
              CopySqueezeDataForObject(obj, t, j, lm_data(Squeeze_lightmap_handle), dest_x, dest_y);
            } else {
              Int3(); // Get Jason, how did this happen????
            }
          }
        }
      }
    }
  }

  if (Squeeze_lightmap_handle != -1) {
    ASSERT(GameLightmaps[Squeeze_lightmap_handle].used != 1);
    GameLightmaps[Squeeze_lightmap_handle].used--;
  }

  // Squeeze all terrain object lightmaps now
  if (external) {

    Squeeze_lightmap_handle = -1;
    for (i = 0; i <= Highest_object_index; i++) {
      object *obj = &Objects[i];

      if (obj->type == OBJ_ROOM)
        continue;
      if (obj->lighting_render_type != LRT_LIGHTMAPS)
        continue;
      if (!obj->lm_object.used)
        continue;
      if (!OBJECT_OUTSIDE(obj))
        continue;

      for (t = 0; t < obj->lm_object.num_models; t++) {
        if (IsNonRenderableSubmodel(&Poly_models[obj->rtype.pobj_info.model_num], t))
          continue;
        for (k = 0; k < obj->lm_object.num_faces[t]; k++) {
          lightmap_object_face *fp = &obj->lm_object.lightmap_faces[t][k];
          int lmi_handle = fp->lmi_handle;
          if (lmi_handle == BAD_LMI_INDEX)
            continue;
          if (Lmi_spoken_for[lmi_handle])
            continue;

          lightmap_info *lmi = &LightmapInfo[lmi_handle];

          int dest_x, dest_y;
          int src_w = lmi->width;
          int src_h = lmi->height;

          if (Squeeze_lightmap_handle == -1) {
            memset(Lightmap_mask, 0, 128 * 128);
            Squeeze_lightmap_handle = lm_AllocLightmap(128, 128);
            uint16_t *fill_data = (uint16_t *)lm_data(Squeeze_lightmap_handle);
            memset(fill_data, 0, 128 * 128 * 2);
          }

          if (FindEmptyMaskSpot(src_w + 2, src_h + 2, &dest_x, &dest_y)) {
            // Cool, found a spot
            CopySqueezeDataForObject(obj, t, k, lm_data(Squeeze_lightmap_handle), dest_x, dest_y);
          } else {
            // Search through the remaining objects on the terrain
            for (int a = i; a <= Highest_object_index; a++) {
              object *obj = &Objects[a];

              if (!obj->lm_object.used)
                continue;
              if (!OBJECT_OUTSIDE(obj))
                continue;

              for (int b = 0; b < obj->lm_object.num_models; b++) {
                if (IsNonRenderableSubmodel(&Poly_models[obj->rtype.pobj_info.model_num], b))
                  continue;
                for (int c = 0; c < obj->lm_object.num_faces[b]; c++) {
                  lightmap_object_face *fp = &obj->lm_object.lightmap_faces[b][c];
                  int lmi_handle = fp->lmi_handle;
                  if (lmi_handle == BAD_LMI_INDEX)
                    continue;
                  if (Lmi_spoken_for[lmi_handle])
                    continue;

                  lightmap_info *lmi = &LightmapInfo[lmi_handle];

                  int src_w = lmi->width;
                  int src_h = lmi->height;

                  if (FindEmptyMaskSpot(src_w + 2, src_h + 2, &dest_x, &dest_y)) {
                    CopySqueezeDataForObject(obj, b, c, lm_data(Squeeze_lightmap_handle), dest_x, dest_y);
                  }
                }
              }
            }

            // Now, allocate a new lightmap and start over
            ASSERT(Squeeze_lightmap_handle != -1);
            ASSERT(GameLightmaps[Squeeze_lightmap_handle].used != 1);
            GameLightmaps[Squeeze_lightmap_handle].used--;

            memset(Lightmap_mask, 0, 128 * 128);
            Squeeze_lightmap_handle = lm_AllocLightmap(128, 128);
            uint16_t *fill_data = (uint16_t *)lm_data(Squeeze_lightmap_handle);
            memset(fill_data, 0, 128 * 128 * 2);

            ASSERT(Lmi_spoken_for[lmi_handle] == 0);

            if (FindEmptyMaskSpot(src_w + 2, src_h + 2, &dest_x, &dest_y)) {
              CopySqueezeDataForObject(obj, t, k, lm_data(Squeeze_lightmap_handle), dest_x, dest_y);
            } else {
              Int3(); // Get Jason, how did this happen????
            }
          }
        }
      }
    }

    if (Squeeze_lightmap_handle != -1) {
      ASSERT(GameLightmaps[Squeeze_lightmap_handle].used != 1);
      GameLightmaps[Squeeze_lightmap_handle].used--;
    }
  }

  mem_free(Lightmap_mask);
  mem_free(Lmi_spoken_for);
  mprintf(0, "Done squeezing lightmaps.\n");
}

void ComputeSurfaceRes(rad_surface *surf, room *rp, int facenum) {
  int i;
  float left = 1.1f, right = -1, top = 1.1f, bottom = -1;
  face *fp = &rp->faces[facenum];
  int lw = lmi_w(fp->lmi_handle);
  int lh = lmi_h(fp->lmi_handle);

  for (i = 0; i < fp->num_verts; i++) {
    if (fp->face_uvls[i].u2 < left)
      left = fp->face_uvls[i].u2;
    if (fp->face_uvls[i].u2 > right)
      right = fp->face_uvls[i].u2;
    if (fp->face_uvls[i].v2 < top)
      top = fp->face_uvls[i].v2;
    if (fp->face_uvls[i].v2 > bottom)
      bottom = fp->face_uvls[i].v2;
  }

  float left_result = (left * lw) + .0001;
  float right_result = (right * lw) + .0001;
  float top_result = (top * lh) + .0001;
  float bottom_result = (bottom * lh) + .0001;

  surf->x1 = floor(left_result);
  surf->x2 = floor(right_result);

  surf->y1 = floor(top_result);
  surf->y2 = floor(bottom_result);

  surf->xresolution = (surf->x2 - surf->x1);
  surf->yresolution = (surf->y2 - surf->y1);

  // Adjust for a accuracy errors
  if (((right_result) - (float)surf->x2) > .005)
    surf->xresolution++;

  if (((bottom_result) - (float)surf->y2) > .005)
    surf->yresolution++;

  if (((top_result) - (float)surf->y1) > .99)
    surf->y1++;

  if (((left_result) - (float)surf->x1) > .99)
    surf->x1++;

  ASSERT((surf->x1 + surf->xresolution) <= lw);
  ASSERT((surf->y1 + surf->yresolution) <= lh);
}

// Take the computed volume spectra of a room and save it in the room struct
void AssignVolumeSpectraToRoom(int roomnum) {
  ASSERT(Rooms[roomnum].used);
  ASSERT(!(Rooms[roomnum].flags & RF_EXTERNAL));
  ASSERT(!(Rooms[roomnum].flags & RF_NO_LIGHT));

  room *rp = &Rooms[roomnum];

  int i, t, j;
  int w = rp->volume_width;
  int h = rp->volume_height;
  int d = rp->volume_depth;

  for (i = 0; i < d; i++) {
    for (t = 0; t < h; t++) {
      for (j = 0; j < w; j++) {
        spectra *this_spectra = &Volume_elements[roomnum][(i * w * h) + (t * w) + j].color;

        if (this_spectra->r < 0) {
          Int3(); // Shouldn't hit this
          rp->volume_lights[(i * w * h) + (t * w) + j] = INVISIBLE_VOLUME_ELEMENT;
        } else {
          float rmax = GetMaxColor(this_spectra);

          if (rmax > 1.0 && rmax > 0.0) {
            this_spectra->r /= rmax;
            this_spectra->g /= rmax;
            this_spectra->b /= rmax;
          }

          int r = (this_spectra->r * 7);
          r <<= 5;
          int g = (this_spectra->g * 7);
          g <<= 2;
          int b = (this_spectra->b * 3);

          uint8_t volume_color = r | g | b;

          if (!UseVolumeLights)
            rp->volume_lights[(i * w * h) + (t * w) + j] = 255;
          else
            rp->volume_lights[(i * w * h) + (t * w) + j] = volume_color;
        }
      }
    }
  }
}

// Returns 0 if there are bad faces in this level
int CheckForBadFaces(int roomnum) {
  int i, t;

  for (i = 0; i <= Highest_room_index; i++) {
    if (roomnum != -1 && i != roomnum)
      continue;

    room *rp = &Rooms[i];
    if (!rp->used)
      continue;

    for (t = 0; t < rp->num_faces; t++) {
      if (rp->faces[t].num_verts < 3)
        return 0; // Bad face detected!
    }
  }

  return 1;
}

// Calculates radiosity and sets lightmaps for indoor faces only
void DoRadiosityForRooms() {
  int i, t, j;
  int facecount = 0;
  int surface_index = 0;
  int max_index;
  int save_after_bsp = 0;

  if (!CheckForBadFaces(-1)) {
    OutrageMessageBox("You have bad faces in your level.  Please do a Verify Level.");
    return;
  }

  MakeBOAVisTable(1);

  if (UseBSP) {
    // if ((MessageBox(NULL,"Do you wish to save the level after BSP construction?","Question",MB_YESNO))==IDYES)
    // save_after_bsp=1;
  }

  BuildBSPTree();

  if (save_after_bsp) {
    char filename[_MAX_PATH];
    ddio_MakePath(filename, cf_GetWritableBaseDirectory().u8string().c_str(), "BSPSave.D3L", NULL);

    // Save the level to
    SaveLevel(filename);
  }

  mprintf(0, "Setting up...\n");

  Lightmaps_for_rad = 0;

  if (UseVolumeLights)
    Do_volume_lighting = 1;

  ClearAllVolumeLights();
  ClearAllRoomLightmaps(0);
  ClearAllObjectLightmaps(0);
  ComputeAllRoomLightmapUVs(0);

  // Figure out memory for volume lights
  int vw, vh, vd;
  for (int roomnum = 0; roomnum < MAX_ROOMS; roomnum++) {
    Volume_elements[roomnum] = NULL;

    if (Rooms[roomnum].used && !(Rooms[roomnum].flags & RF_EXTERNAL) && !(Rooms[roomnum].flags & RF_NO_LIGHT)) {
      int num_bytes = GetVolumeSizeOfRoom(&Rooms[roomnum], &vw, &vh, &vd);

      Rooms[roomnum].volume_width = vw;
      Rooms[roomnum].volume_height = vh;
      Rooms[roomnum].volume_depth = vd;

      Rooms[roomnum].volume_lights = (uint8_t *)mem_malloc(vw * vh * vd);
      ASSERT(Rooms[roomnum].volume_lights);

      Volume_elements[roomnum] = mem_rmalloc<volume_element>(vw * vh * vd);
      ASSERT(Volume_elements[roomnum]);

      // Now go through and find all the valid spectra points
      float cur_z = Rooms[roomnum].min_xyz.z + .1;

      for (i = 0; i < vd; i++, cur_z += VOLUME_SPACING) {
        float cur_y = Rooms[roomnum].min_xyz.y + .1;
        for (t = 0; t < vh; t++, cur_y += VOLUME_SPACING) {
          float cur_x = Rooms[roomnum].min_xyz.x + .1;
          for (j = 0; j < vw; j++, cur_x += VOLUME_SPACING) {
            vector dest_vec;
            dest_vec.x = cur_x;
            dest_vec.y = cur_y;
            dest_vec.z = cur_z;

            Volume_elements[roomnum][(i * vw * vh) + (t * vw) + j].pos = dest_vec;

            if (FindPointRoom(&dest_vec) != roomnum) {
              Volume_elements[roomnum][(i * vw * vh) + (t * vw) + j].color.r = 0;
              Volume_elements[roomnum][(i * vw * vh) + (t * vw) + j].flags = VEF_REVERSE_SHOOT;
            } else {
              Volume_elements[roomnum][(i * vw * vh) + (t * vw) + j].color.r = 0;
              Volume_elements[roomnum][(i * vw * vh) + (t * vw) + j].flags = 0;
            }
          }
        }
      }
    }
  }

  // First count how many faces we'll need
  for (i = 0; i < MAX_ROOMS; i++) {
    if (Rooms[i].used && !(Rooms[i].flags & RF_EXTERNAL) && !(Rooms[i].flags & RF_NO_LIGHT)) {
      facecount += Rooms[i].num_faces;
    }
  }

  // Setup specular lighting
  Calculate_specular_lighting = 1;
  SetupSpecularLighting(0);

  // Do objects
  facecount += GetTotalObjectFaces(0);
  // Do satellites
  facecount += Terrain_sky.num_satellites;

  // Allocate enough memory to hold all surfaces

  Light_surfaces = mem_rmalloc<rad_surface>(facecount);
  ASSERT(Light_surfaces != NULL);

  // Set initial surface properties
  max_index = surface_index = 0;

  for (i = 0; i < MAX_ROOMS; i++) {
    if (Rooms[i].used) {
      if ((Rooms[i].flags & RF_EXTERNAL) || (Rooms[i].flags & RF_NO_LIGHT))
        continue;

      for (t = 0; t < Rooms[i].num_faces; t++, surface_index++, max_index++) {

        ComputeSurfaceRes(&Light_surfaces[surface_index], &Rooms[i], t);

        if (Rooms[i].faces[t].num_verts) {
          Light_surfaces[surface_index].verts = mem_rmalloc<vector>(Rooms[i].faces[t].num_verts);
          ASSERT(Light_surfaces[surface_index].verts != NULL);
        } else {
          Light_surfaces[surface_index].verts = NULL;
          mprintf(0, "Room=%d Face %d has no verts!\n", i, t);
        }

        if (Light_surfaces[surface_index].xresolution * Light_surfaces[surface_index].yresolution) {
          Light_surfaces[surface_index].elements =
               mem_rmalloc<rad_element>(Light_surfaces[surface_index].xresolution *
                                        Light_surfaces[surface_index].yresolution);
          ASSERT(Light_surfaces[surface_index].elements != NULL);
        } else {
          Light_surfaces[surface_index].elements = NULL;
          mprintf(0, "Room=%d Face %d is slivered!\n", i, t);
        }

        Light_surfaces[surface_index].flags = 0;

        if (Rooms[i].faces[t].portal_num != -1 &&
            (((Rooms[i].portals[Rooms[i].faces[t].portal_num].flags & PF_RENDER_FACES) == 0) ||
             ((Rooms[i].portals[Rooms[i].faces[t].portal_num].flags & PF_RENDER_FACES) &&
              (GameTextures[Rooms[i].faces[t].tmap].flags & TF_TMAP2))))

        {
          Light_surfaces[surface_index].surface_type = ST_PORTAL;
          Light_surfaces[surface_index].emittance.r = 0;
          Light_surfaces[surface_index].emittance.g = 0;
          Light_surfaces[surface_index].emittance.b = 0;
        } else {
          if (Rooms[i].faces[t].light_multiple > 200)
            Rooms[i].faces[t].light_multiple = 4;

          float mul = ((float)Rooms[i].faces[t].light_multiple) / 4.0;
          mul *= GlobalMultiplier * Room_multiplier[i];

          Light_surfaces[surface_index].emittance.r = (float)GameTextures[Rooms[i].faces[t].tmap].r * mul;
          Light_surfaces[surface_index].emittance.g = (float)GameTextures[Rooms[i].faces[t].tmap].g * mul;
          Light_surfaces[surface_index].emittance.b = (float)GameTextures[Rooms[i].faces[t].tmap].b * mul;
          Light_surfaces[surface_index].surface_type = ST_ROOM;

          if ((GetMaxColor(&Light_surfaces[surface_index].emittance)) > .005)
            Light_surfaces[surface_index].flags |= SF_LIGHTSOURCE;
        }

        Light_surfaces[surface_index].normal = LightmapInfo[Rooms[i].faces[t].lmi_handle].normal;
        Light_surfaces[surface_index].roomnum = i;
        Light_surfaces[surface_index].facenum = t;

        if (Rooms[i].flags & RF_TOUCHES_TERRAIN)
          Light_surfaces[surface_index].flags |= SF_TOUCHES_TERRAIN;

        for (int k = 0; k < Rooms[i].num_portals; k++) {
          if (Rooms[i].portals[k].croom == -1 || (Rooms[Rooms[i].portals[k].croom].flags & RF_EXTERNAL))
            Light_surfaces[surface_index].flags |= SF_TOUCHES_TERRAIN;
        }

        Light_surfaces[surface_index].reflectivity = GameTextures[Rooms[i].faces[t].tmap].reflectivity;

        // Set the vertices for each element
        BuildElementListForRoomFace(i, t, &Light_surfaces[surface_index]);

        int xres = Light_surfaces[surface_index].xresolution;
        int yres = Light_surfaces[surface_index].yresolution;
      }
    }
  }

  // Setup satellites
  for (i = 0; i < Terrain_sky.num_satellites; i++, surface_index++) {
    Light_surfaces[surface_index].verts = mem_rmalloc<vector>(3);
    ASSERT(Light_surfaces[surface_index].verts != NULL);

    Light_surfaces[surface_index].elements = mem_rmalloc<rad_element>();
    ASSERT(Light_surfaces[surface_index].elements != NULL);

    Light_surfaces[surface_index].elements[0].verts = mem_rmalloc<vector>(3);
    ASSERT(Light_surfaces[surface_index].elements[0].verts);

    Light_surfaces[surface_index].surface_type = ST_SATELLITE;
    Light_surfaces[surface_index].emittance.r = Terrain_sky.satellite_r[i];
    Light_surfaces[surface_index].emittance.g = Terrain_sky.satellite_g[i];
    Light_surfaces[surface_index].emittance.b = Terrain_sky.satellite_b[i];

    Light_surfaces[surface_index].roomnum = i;
    Light_surfaces[surface_index].facenum = 0;

    Light_surfaces[surface_index].reflectivity = 0;
    Light_surfaces[surface_index].xresolution = 1;
    Light_surfaces[surface_index].yresolution = 1;

    vm_MakeZero(&Light_surfaces[surface_index].normal);

    Light_surfaces[surface_index].verts[0] = Terrain_sky.satellite_vectors[i];
    Light_surfaces[surface_index].verts[1] = Terrain_sky.satellite_vectors[i];
    Light_surfaces[surface_index].verts[2] = Terrain_sky.satellite_vectors[i];
    Light_surfaces[surface_index].num_verts = 3;

    Light_surfaces[surface_index].elements[0].verts[0] = Terrain_sky.satellite_vectors[i];
    Light_surfaces[surface_index].elements[0].verts[1] = Terrain_sky.satellite_vectors[i];
    Light_surfaces[surface_index].elements[0].verts[2] = Terrain_sky.satellite_vectors[i];
    Light_surfaces[surface_index].elements[0].num_verts = 3;

    Light_surfaces[surface_index].elements[0].flags = 0;
  }

  // Setup Objects
  ComputeSurfacesForObjects(surface_index, 0);

  mprintf(0, "This radiosity run is using %d lightmaps.\n", Lightmaps_for_rad);
  mprintf(0, "Solving radiosity equation (press tilde key to stop)...\n");
  if (D3EditState.hemicube_radiosity)
    DoRadiosityRun(SM_HEMICUBE, Light_surfaces, facecount);
  else
    DoRadiosityRun(SM_RAYCAST, Light_surfaces, facecount);
  mprintf(0, "Done solving radiosity - cleaning up...\n");

  surface_index = 0;

  // Assign lightap properties
  for (i = 0; i < MAX_ROOMS; i++) {
    if (Rooms[i].used) {
      if ((Rooms[i].flags & RF_EXTERNAL) || (Rooms[i].flags & RF_NO_LIGHT))
        continue;

      for (t = 0; t < Rooms[i].num_faces; t++, surface_index++) {
        AssignRoomSurfaceToLightmap(i, t, &Light_surfaces[surface_index]);
      }

      AssignVolumeSpectraToRoom(i);
      mem_free(Volume_elements[i]);
    }
  }

  surface_index += Terrain_sky.num_satellites;

  AssignLightmapsToObjectSurfaces(surface_index, 0);

  BlurLightmapInfos(LMI_ROOM);
  BlurLightmapInfos(LMI_ROOM_OBJECT);

  ShadeLightmapInfoEdges(LMI_ROOM);
  ShadeLightmapInfoEdges(LMI_ROOM_OBJECT);

  // Free our memory

  for (i = 0; i < facecount; i++) {
    if (Light_surfaces[i].verts)
      mem_free(Light_surfaces[i].verts);
    for (t = 0; t < Light_surfaces[i].xresolution * Light_surfaces[i].yresolution; t++)
      if (Light_surfaces[i].elements[t].num_verts > 0)
        mem_free(Light_surfaces[i].elements[t].verts);

    if (Light_surfaces[i].elements)
      mem_free(Light_surfaces[i].elements);
    Light_surfaces[i].elements = NULL;
  }
  mem_free(Light_surfaces);
  Light_surfaces = NULL;
  Do_volume_lighting = 0;

  // Free specular lighting stuff
  CleanupSpecularLighting(0);
  Calculate_specular_lighting = 0;

  // Figure out combined portals
  CheckCombinePortals(0);

  // Finally, squeeze the lightmaps
  SqueezeLightmaps(0, -1);

  char filename[_MAX_PATH + 1];
  ddio_MakePath(filename, cf_GetWritableBaseDirectory().u8string().c_str(), "LightSave.D3L", NULL);

  // Save the level to disk
  SaveLevel(filename);

  OutrageMessageBox("Mine radiosity complete!");
}

// Calculates radiosity and sets lightmaps for indoor faces only
void DoRadiosityForCurrentRoom(room *rp) {
  int t;
  int facecount = 0;
  int surface_index = 0;
  int max_index;

  if (!CheckForBadFaces(rp - Rooms)) {
    OutrageMessageBox("You have bad faces in your level.  Please do a Verify Level.");
    return;
  }

  mprintf(0, "Setting up...\n");

  ASSERT(rp != NULL);
  ASSERT(rp->used);

  if (rp->flags & RF_EXTERNAL) {
    OutrageMessageBox("You cannot run single room radiosity on external rooms!");
    return;
  }

  if (rp->flags & RF_NO_LIGHT) {
    OutrageMessageBox("You cannot run single room radiosity on a room marked not to light!");
    return;
  }

  // Build bsp tree
  BuildSingleBSPTree(rp - Rooms);

  ClearRoomLightmaps(rp - Rooms);
  for (t = 0; t <= Highest_object_index; t++) {
    if (Objects[t].type != OBJ_NONE && (Objects[t].roomnum == rp - Rooms))
      ClearObjectLightmaps(&Objects[t]);
  }

  // Build lightmap uvs
  for (t = 0; t < rp->num_faces; t++) {
    vector verts[MAX_VERTS_PER_FACE * 5];
    int room_list[2], face_list[2];
    for (int k = 0; k < rp->faces[t].num_verts; k++)
      verts[k] = rp->verts[rp->faces[t].face_verts[k]];

    room_list[0] = rp - Rooms;
    face_list[0] = t;

    BuildLightmapUVs(room_list, face_list, 1, verts, rp->faces[t].num_verts, 0);
  }

  // First count how many faces we'll need
  facecount += rp->num_faces;

  // Do objects
  facecount += GetTotalObjectFacesForSingleRoom(rp - Rooms);

  // Allocate enough memory to hold all surfaces

  Light_surfaces = mem_rmalloc<rad_surface>(facecount);
  ASSERT(Light_surfaces != NULL);

  // Set initial surface properties
  max_index = surface_index = 0;

  for (t = 0; t < rp->num_faces; t++, surface_index++, max_index++) {
    ComputeSurfaceRes(&Light_surfaces[surface_index], rp, t);

    if (rp->faces[t].num_verts) {
      Light_surfaces[surface_index].verts = mem_rmalloc<vector>(rp->faces[t].num_verts);
      ASSERT(Light_surfaces[surface_index].verts != NULL);
    } else {
      Light_surfaces[surface_index].verts = NULL;
      mprintf(0, "Room=%d Face %d has no verts!\n", rp - Rooms, t);
    }

    if (Light_surfaces[surface_index].xresolution * Light_surfaces[surface_index].yresolution) {
      Light_surfaces[surface_index].elements = mem_rmalloc<rad_element>(
          Light_surfaces[surface_index].xresolution * Light_surfaces[surface_index].yresolution);
      ASSERT(Light_surfaces[surface_index].elements != NULL);
    } else {
      Light_surfaces[surface_index].elements = NULL;
      mprintf(0, "Room=%d Face %d is slivered!\n", rp - Rooms, t);
    }

    if (rp->faces[t].portal_num != -1 && (((rp->portals[rp->faces[t].portal_num].flags & PF_RENDER_FACES) == 0) ||
                                          ((rp->portals[rp->faces[t].portal_num].flags & PF_RENDER_FACES) &&
                                           (GameTextures[rp->faces[t].tmap].flags & TF_TMAP2)))) {
      Light_surfaces[surface_index].surface_type = ST_PORTAL;
      Light_surfaces[surface_index].emittance.r = 0;
      Light_surfaces[surface_index].emittance.g = 0;
      Light_surfaces[surface_index].emittance.b = 0;
    } else {
      float mul = ((float)rp->faces[t].light_multiple) / 4.0;
      mul *= GlobalMultiplier * Room_multiplier[rp - Rooms];
      Light_surfaces[surface_index].emittance.r = (float)GameTextures[rp->faces[t].tmap].r * mul;
      Light_surfaces[surface_index].emittance.g = (float)GameTextures[rp->faces[t].tmap].g * mul;
      Light_surfaces[surface_index].emittance.b = (float)GameTextures[rp->faces[t].tmap].b * mul;
      Light_surfaces[surface_index].surface_type = ST_ROOM;
    }

    Light_surfaces[surface_index].normal = rp->faces[t].normal;
    Light_surfaces[surface_index].roomnum = ROOMNUM(rp);
    Light_surfaces[surface_index].facenum = t;

    Light_surfaces[surface_index].reflectivity = GameTextures[rp->faces[t].tmap].reflectivity;

    // Set the vertices for each element
    BuildElementListForRoomFace(rp - Rooms, t, &Light_surfaces[surface_index]);

    int xres = Light_surfaces[surface_index].xresolution;
    int yres = Light_surfaces[surface_index].yresolution;
  }

  // Setup Objects
  ComputeSurfacesForObjectsForSingleRoom(surface_index, rp - Rooms);

  mprintf(0, "Solving radiosity equation (press tilde key to stop)...\n");
  if (D3EditState.hemicube_radiosity)
    DoRadiosityRun(SM_HEMICUBE, Light_surfaces, facecount);
  else
    DoRadiosityRun(SM_RAYCAST, Light_surfaces, facecount);
  mprintf(0, "Done solving radiosity - cleaning up...\n");

  surface_index = 0;

  // Assign lightap properties
  for (t = 0; t < rp->num_faces; t++, surface_index++) {
    AssignRoomSurfaceToLightmap(rp - Rooms, t, &Light_surfaces[surface_index]);
  }

  AssignLightmapsToObjectSurfacesForSingleRoom(surface_index, rp - Rooms);

  // BlurLightmapInfos (LMI_ROOM);
  // BlurLightmapInfos (LMI_ROOM_OBJECT);

  // ShadeLightmapInfoEdges (LMI_ROOM);
  // ShadeLightmapInfoEdges (LMI_ROOM_OBJECT);

  // Free our memory

  for (int i = 0; i < facecount; i++) {
    mem_free(Light_surfaces[i].verts);
    for (t = 0; t < Light_surfaces[i].xresolution * Light_surfaces[i].yresolution; t++)
      if (Light_surfaces[i].elements[t].num_verts > 0)
        mem_free(Light_surfaces[i].elements[t].verts);

    mem_free(Light_surfaces[i].elements);
    Light_surfaces[i].elements = NULL;
  }
  mem_free(Light_surfaces);
  Light_surfaces = NULL;

  // Finally, squeeze the lightmaps
  SqueezeLightmaps(0, rp - Rooms);

  OutrageMessageBox("Room radiosity complete!");
}

// Allocates and sets a lightmap based on the surface elements given
void AssignRoomSurfaceToLightmap(int roomnum, int facenum, rad_surface *sp) {
  face *fp = &Rooms[roomnum].faces[facenum];
  room *rp = &Rooms[roomnum];

  int i, t, lmi_handle;
  int xres, yres;
  int lw, lh;
  int x1 = sp->x1;
  int y1 = sp->y1;
  int use_lightmap = 1;

  xres = sp->xresolution;
  yres = sp->yresolution;

  ASSERT(fp->lmi_handle != BAD_LMI_INDEX);
  lmi_handle = fp->lmi_handle;

  lw = lmi_w(lmi_handle);
  lh = lmi_h(lmi_handle);

  ASSERT((xres + x1) <= lw);
  ASSERT((yres + y1) <= lh);

  ASSERT(lw >= 2);
  ASSERT(lh >= 2);

  uint16_t *dest_data = lm_data(LightmapInfo[lmi_handle].lm_handle);

  // Set face pointer
  if (GameTextures[fp->tmap].flags & TF_ALPHA)
    use_lightmap = 0;
  if (GameTextures[fp->tmap].flags & (TF_FORCE_LIGHTMAP | TF_SATURATE_LIGHTMAP))
    use_lightmap = 1;

  if (use_lightmap)
    fp->flags |= FF_LIGHTMAP;

  for (i = 0; i < yres; i++) {
    for (t = 0; t < xres; t++) {
      if (!(sp->elements[i * xres + t].flags & EF_IGNORE)) {
        ddgr_color color = GR_16_TO_COLOR(dest_data[(i + y1) * lw + (t + x1)]);
        int red = GR_COLOR_RED(color);
        int green = GR_COLOR_GREEN(color);
        int blue = GR_COLOR_BLUE(color);

        float fr, fg, fb;

        if (!(dest_data[(i + y1) * lw + (t + x1)] & OPAQUE_FLAG)) {
          red = green = blue = 0;
        }

        fr = std::min(1.0f, sp->elements[i * xres + t].exitance.r + Ambient_red + Room_ambience_r[roomnum]);
        fg = std::min(1.0f, sp->elements[i * xres + t].exitance.g + Ambient_green + Room_ambience_g[roomnum]);
        fb = std::min(1.0f, sp->elements[i * xres + t].exitance.b + Ambient_blue + Room_ambience_b[roomnum]);

        fr = (fr * 255) + .5;
        fg = (fg * 255) + .5;
        fb = (fb * 255) + .5;

        red += (int)fr;
        green += (int)fg;
        blue += (int)fb;

        if (dest_data[(i + y1) * lw + (t + x1)] & OPAQUE_FLAG) {

          red /= 2;
          green /= 2;
          blue /= 2;
        }

        red = std::min(red, 255);
        green = std::min(green, 255);
        blue = std::min(blue, 255);

        uint16_t texel = OPAQUE_FLAG | GR_RGB16(red, green, blue);

        dest_data[(i + y1) * lw + (t + x1)] = texel;
      }
    }
  }
}

// Important - vertnum is the index into the face_verts[] array in the face structure,
// not an index into the verts[] array of the room structure
void BuildElementListForRoomFace(int roomnum, int facenum, rad_surface *surf) {
  matrix face_matrix, trans_matrix;
  vector fvec;
  vector avg_vert;
  vector verts[MAX_VERTS_PER_FACE * 5];
  vector rot_vert;
  vector vert;
  int i, t;
  int xres, yres;
  int lmi_handle;
  int x1 = surf->x1;
  int y1 = surf->y1;

  xres = surf->xresolution;
  yres = surf->yresolution;

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

  lmi_handle = Rooms[roomnum].faces[facenum].lmi_handle;
  avg_vert = ScratchCenters[lmi_handle];

  // Make the orientation matrix
  // Reverse the normal because we're looking "at" the face, not from it
  fvec = -LightmapInfo[lmi_handle].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++) {
    vert = Rooms[roomnum].verts[Rooms[roomnum].faces[facenum].face_verts[i]];

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

    verts[i] = rot_vert;
  }

  // Find a base vector
  vector base_vector;
  vector xdiff, ydiff;

  vm_MakeZero(&xdiff);
  vm_MakeZero(&ydiff);

  // Rotate our upper left point into our 2d space
  vert = LightmapInfo[lmi_handle].upper_left - avg_vert;
  vm_MatrixMulVector(&base_vector, &vert, &trans_matrix);

  xdiff.x = LightmapInfo[lmi_handle].xspacing;
  ydiff.y = LightmapInfo[lmi_handle].yspacing;

  vm_TransposeMatrix(&trans_matrix);

  for (i = 0; i < yres; i++) {
    for (t = 0; t < xres; t++) {
      int element_index = i * xres + t;
      vector clip_verts[4];

      rad_element *ep = &surf->elements[element_index];

      // Allocate some free space
      clip_verts[0] = base_vector + (xdiff * (t + x1)) - (ydiff * (i + y1));
      clip_verts[1] = base_vector + (xdiff * (t + x1 + 1)) - (ydiff * (i + y1));
      clip_verts[2] = base_vector + (xdiff * (t + x1 + 1)) - (ydiff * (i + y1 + 1));
      clip_verts[3] = base_vector + (xdiff * (t + x1)) - (ydiff * (i + y1 + 1));
      ClipSurfaceElement(verts, ep, clip_verts, Rooms[roomnum].faces[facenum].num_verts);

      for (int k = 0; k < ep->num_verts; k++) {
        vm_MatrixMulVector(&rot_vert, &ep->verts[k], &trans_matrix);
        ep->verts[k] = rot_vert + avg_vert;
      }
    }
  }

  if (Square_surfaces) {
    surf->verts[0] = base_vector;
    surf->verts[1] = base_vector + (xdiff * xres);
    surf->verts[2] = base_vector + (xdiff * xres) - (ydiff * yres);
    surf->verts[3] = base_vector - (ydiff * yres);

    for (int k = 0; k < 4; k++) {
      vm_MatrixMulVector(&rot_vert, &surf->verts[k], &trans_matrix);
      surf->verts[k] = rot_vert + avg_vert;
    }
    surf->num_verts = 4;
  } else {

    surf->num_verts = Rooms[roomnum].faces[facenum].num_verts;
    for (int k = 0; k < surf->num_verts; k++) {
      surf->verts[k] = Rooms[roomnum].verts[Rooms[roomnum].faces[facenum].face_verts[k]];
    }
  }
}

vector *rad_ClipTop, *rad_ClipBottom, *rad_ClipLeft, *rad_ClipRight;
rad_point GlobalTempRadPoint;

void SetRadClipLines(vector *tp, vector *rp, vector *bp, vector *lp) {
  rad_ClipTop = tp;
  rad_ClipRight = rp;
  rad_ClipBottom = bp;
  rad_ClipLeft = lp;
}

uint8_t CodeRadPoint(rad_point *rp) {
  uint8_t code = 0;
  if (rp->pos.x < rad_ClipLeft->x)
    code |= CC_OFF_LEFT;
  if (rp->pos.x > rad_ClipRight->x)
    code |= CC_OFF_RIGHT;
  if (rp->pos.y < rad_ClipBottom->y)
    code |= CC_OFF_BOT;
  if (rp->pos.y > rad_ClipTop->y)
    code |= CC_OFF_TOP;
  rp->code = code;

  return code;
}

void ClipSurfaceElement(vector *surf_verts, rad_element *ep, vector *clip_verts, int nv) {
  rad_point src_verts[50];
  rad_point dest_verts[50];
  rad_point *slist, *dlist;
  uint8_t and = 0xff;
  uint8_t or = 0;
  int i;

  ASSERT(nv < 50);

  ep->flags = 0;

  SetRadClipLines(&clip_verts[0], &clip_verts[1], &clip_verts[2], &clip_verts[3]);

  for (i = 0; i < nv; i++) {
    src_verts[i].pos = surf_verts[i];
    src_verts[i].code = CodeRadPoint(&src_verts[i]);
  }

  for (i = 0; i < nv; i++) {
    and &= src_verts[i].code;
    or |= src_verts[i].code;
  }

  if (and) {
    // This element is not even in the face, ignore it
    ep->flags |= EF_IGNORE;
    ep->num_verts = 0;
    return;
  }

  int pnv = nv, nnv;
  slist = src_verts;
  dlist = dest_verts;

  nnv = ClipRadPointList(&slist, &dlist, &pnv, or);

  ep->num_verts = nnv;

  if (ep->num_verts == 0)
    ep->flags |= EF_IGNORE;
  else {
    ep->verts = mem_rmalloc<vector>(nnv);
    ASSERT(ep->verts);

    for (i = 0; i < nnv; i++) {
      ep->verts[i] = dlist[i].pos;
    }
  }
}

// Takes a points and clips all its viewpoints so they fit into the view frustum
// Puts the new clipped list in dest
// Returns number of points in clipped polygon

int ClipRadPointList(rad_point **src, rad_point **dest, int *nv, int code) {
  int plane, num = 0;
  rad_point **save_src = src, *t;
  rad_point **save_dest = dest;

  for (plane = 1; plane < 16; plane <<= 1) {
    if (plane & code) // Is this point off this plane?
    {

      *nv = ClipRadToPlane(plane, *src, *dest, *nv);
      if (*nv == 0)
        return 0;
      ASSERT(*nv >= 3);

      t = *dest;
      *dest = *src;
      *src = t;
      num++;
    }
  }

  t = *dest;
  *dest = *src;
  *src = t;

  return (*nv);
}

// Clips to a specific plane, putting resulting points in dest and returning number of points in dest
int ClipRadToPlane(int plane, rad_point *src, rad_point *dest, int nv) {
  int i, num = 0, limit = nv - 1, ppoint, npoint;

  ASSERT(nv >= 3);

  for (i = 0; i < nv; i++) {
    if (i == limit)
      npoint = 0;
    else
      npoint = i + 1;

    if (i == 0)
      ppoint = limit;
    else
      ppoint = i - 1;

    // mprintf(0,"checking point %d ",i);
    if (src[i].code & plane) // off this plane?
    {

      if (!(src[ppoint].code & plane)) // prev point on?
      {
        // mprintf(0,"pVertex %d off %d plane.\n",i,plane);
        ClipRadEdge(plane, &src[ppoint], &src[i]);

        memcpy(&dest[num], &GlobalTempRadPoint, sizeof(rad_point));
        num++;
      }

      if (!(src[npoint].code & plane)) // next point on?
      {

        // mprintf(0,"nVertex %d off %d plane.\n",i,plane);
        ClipRadEdge(plane, &src[npoint], &src[i]);

        memcpy(&dest[num], &GlobalTempRadPoint, sizeof(rad_point));
        num++;
      }

    } else // This point is on
    {

      // mprintf(0,"is on\n");
      memcpy(&dest[num], &src[i], sizeof(rad_point));
      num++;
    }
  }
  return (num);
}

// Takes two points and a plane, and clips.
void ClipRadEdge(int plane_flag, rad_point *on_pnt, rad_point *off_pnt) {
  if (plane_flag & CC_OFF_TOP) {
    float percent_on = 1.0 - ((off_pnt->pos.y - rad_ClipTop->y) / (off_pnt->pos.y - on_pnt->pos.y));
    GlobalTempRadPoint.pos = on_pnt->pos + ((off_pnt->pos - on_pnt->pos) * percent_on);
  }

  if (plane_flag & CC_OFF_RIGHT) {
    float percent_on = 1.0 - ((off_pnt->pos.x - rad_ClipRight->x) / (off_pnt->pos.x - on_pnt->pos.x));
    GlobalTempRadPoint.pos = on_pnt->pos + ((off_pnt->pos - on_pnt->pos) * percent_on);
  }

  if (plane_flag & CC_OFF_LEFT) {
    float percent_on = 1.0 - ((off_pnt->pos.x - rad_ClipLeft->x) / (off_pnt->pos.x - on_pnt->pos.x));
    GlobalTempRadPoint.pos = on_pnt->pos + ((off_pnt->pos - on_pnt->pos) * percent_on);
  }

  if (plane_flag & CC_OFF_BOT) {
    float percent_on = 1.0 - ((off_pnt->pos.y - rad_ClipBottom->y) / (off_pnt->pos.y - on_pnt->pos.y));
    GlobalTempRadPoint.pos = on_pnt->pos + ((off_pnt->pos - on_pnt->pos) * percent_on);
  }

  CodeRadPoint(&GlobalTempRadPoint);
}

// Adds color spectrums together
void AddSpectra(spectra *dest, spectra *a, spectra *b) {
  dest->r = a->r + b->r;
  dest->g = a->g + b->g;
  dest->b = a->b + b->b;
}

// Returns 1 if a src vector can hit dest vector unobstructed, else 0
int ShootRayForTerrainLight(vector *src, vector *dest, int cellnum) {
  fvi_info hit_info;
  fvi_query fq;
  vector temp_dest = *dest;

  if (temp_dest.y >= MAX_TERRAIN_HEIGHT * 3) {
    float mag;
    float ydiff;
    vector ray = temp_dest - *src;

    mag = vm_GetMagnitude(&ray);
    ray /= mag;

    ydiff = ((MAX_TERRAIN_HEIGHT * 3) - src->y) / ray.y;

    temp_dest = *src + (ray * ydiff);
  }

  // shoot a ray from the light position to the current vertex
  fq.p0 = src;
  fq.p1 = &temp_dest;
  fq.startroom = MAKE_ROOMNUM(cellnum);

  fq.rad = 0.0f;
  fq.flags = FQ_CHECK_OBJS | FQ_IGNORE_NON_LIGHTMAP_OBJECTS | FQ_OBJ_BACKFACE | FQ_NO_RELINK |
             FQ_IGNORE_RENDER_THROUGH_PORTALS;
  fq.thisobjnum = -1;
  fq.ignore_obj_list = NULL;

  int fate = fvi_FindIntersection(&fq, &hit_info);

  if (fate == HIT_OUT_OF_TERRAIN_BOUNDS || fate == HIT_NONE)
    return 1;

  return 0;
}

#define AREA_X (TERRAIN_WIDTH - 1)
#define AREA_Z (TERRAIN_DEPTH - 1)
// #define AREA_X	128
// #define AREA_Z	128

// Puts a 3d grid of points on the terrain and sets a bit indicating if a light source
// can reach that point.  This is used for the dynamic lighting of objects on the terrain
void DoTerrainDynamicTable() {
  int i, t, k, j, maxrays;
  int raynum = 0;
  int key;

  maxrays = AREA_X * AREA_Z * 8 * Terrain_sky.num_satellites;

  mprintf(0, "Calculating dynamic light table for %d points...\n", maxrays);
  mprintf(0, "Press tilde key to abort!\n");

  memset(Terrain_dynamic_table, 0, (TERRAIN_DEPTH * TERRAIN_WIDTH));

  for (i = 0; i < AREA_Z; i++) {
    //	ddio_KeyFrame();
    while ((key = ddio_KeyInKey()) != 0) {
      if (key == KEY_LAPOSTRO) {
        for (; i < AREA_Z; i++) {
          for (t = 0; t < AREA_X; t++) {
            int tseg = i * TERRAIN_WIDTH + t;
            Terrain_dynamic_table[tseg] = 255;
          }
        }

        return;
      }
    }

    for (t = 0; t < AREA_X; t++) {
      int tseg = i * TERRAIN_WIDTH + t;
      vector gp;

      gp.x = (t * TERRAIN_SIZE);
      gp.z = (i * TERRAIN_SIZE);

      gp.y = Terrain_seg[tseg].y;

      for (k = 0; k < 8; k++) {
        vector pos;

        pos.x = gp.x;
        pos.z = gp.z;
        pos.y = k * (MAX_TERRAIN_HEIGHT / 8);

        for (j = 0; j < Terrain_sky.num_satellites; j++) {
          raynum++;

          if (gp.y > pos.y)
            continue;

          int answer;
          answer = ShootRayForTerrainLight(&pos, &Terrain_sky.satellite_vectors[j], tseg);
          if (!answer)
            continue;

          Terrain_dynamic_table[tseg] |= (1 << k);
          j = Terrain_sky.num_satellites;
        }
      }
    }
  }
}

void ComputeTerrainSpeedTable() {
  int i, t, j, raynum = 0;

  mprintf(0, "Precomputing terrain speed table...(%d rays)\n", AREA_X * AREA_Z);
  for (i = 0; i < AREA_Z; i++) {
    for (t = 0; t < AREA_X; t++) {
      int tseg = i * TERRAIN_WIDTH + t;
      vector pos;

      pos.x = (t * TERRAIN_SIZE);
      pos.z = (i * TERRAIN_SIZE);
      pos.y = (Terrain_seg[tseg].y) + .001;

      raynum++;

      for (j = 0; j < Terrain_sky.num_satellites; j++)
        TerrainLightSpeedup[j][tseg] = ShootRayForTerrainLight(&pos, &Terrain_sky.satellite_vectors[j], tseg);
    }
  }
}

float GetMaxColor(spectra *sp);

// Calculates radiosity for the outdoor surfaces
void DoRadiosityForTerrain() {
  int i, t, raynum = 0;
  int extra_surfaces = 0, total_surfaces = 0;
  int surf_index = 0;
  spectra *terrain_sums[2];
  int room_surf_start, obj_surf_start;

  int do_dynamic = 0;
  int lit = 0;

  // First make sure there is even a light source
  for (i = 0; i < Terrain_sky.num_satellites; i++) {
    int tmap = Terrain_sky.satellite_texture[i];
    if (Terrain_sky.satellite_r[i] > 0 || Terrain_sky.satellite_g[i] > 0 || Terrain_sky.satellite_b[i] > 0)
      lit = 1;
  }

  if (!lit) {
    OutrageMessageBox("No moons/suns cast light so there is no point in running terrain radiosity!");
    return;
  }

  for (i = 0; i < Terrain_sky.num_satellites; i++) {
    TerrainLightSpeedup[i] = (uint8_t *)mem_malloc(TERRAIN_WIDTH * TERRAIN_DEPTH);
    ASSERT(TerrainLightSpeedup[i]);
  }

  if ((MessageBox(NULL,
                  "Do you wish to calculate dynamic terrain lighting when radiosity is completed? (Note: Dynamic "
                  "lighting takes a long time)",
                  "Question", MB_YESNO)) == IDYES)
    do_dynamic = 1;

  if (!Ignore_terrain)
    ComputeTerrainSpeedTable();

  extra_surfaces += Terrain_sky.num_satellites;
  extra_surfaces += GetTotalObjectFaces(1);

  // Get our external rooms ready
  ClearAllRoomLightmaps(1);
  ComputeAllRoomLightmapUVs(1);

  // count how many faces we'll need
  for (i = 0; i < MAX_ROOMS; i++) {
    if (Rooms[i].used && (Rooms[i].flags & RF_EXTERNAL))
      extra_surfaces += Rooms[i].num_faces;
  }

  if (!Ignore_terrain)
    total_surfaces = ((AREA_X) * (AREA_Z) * 2);
  total_surfaces += extra_surfaces;

  // Get our object lightmaps ready
  ClearAllObjectLightmaps(1);

  // Allocate memory
  terrain_sums[0] = mem_rmalloc<spectra>(TERRAIN_WIDTH * TERRAIN_DEPTH);
  terrain_sums[1] = mem_rmalloc<spectra>(TERRAIN_WIDTH * TERRAIN_DEPTH);
  ASSERT(terrain_sums[0] && terrain_sums[1]);

  Light_surfaces = mem_rmalloc<rad_surface>(total_surfaces);
  ASSERT(Light_surfaces != NULL);

  // Setup radiosity surfaces
  if (!Ignore_terrain) {
    for (i = 0; i < (AREA_X) * (AREA_Z); i++, surf_index += 2) {
      vector a, b, c;
      int x, z;

      x = i % AREA_X;
      z = i / AREA_Z;

      int seg = z * TERRAIN_WIDTH + x;

      // Do common stuff (for both triangles)
      for (x = 0; x < 2; x++) {
        Light_surfaces[i * 2 + x].surface_type = ST_TERRAIN;
        Light_surfaces[i * 2 + x].emittance.r =
            (float)GameTextures[Terrain_tex_seg[Terrain_seg[seg].texseg_index].tex_index].r;
        Light_surfaces[i * 2 + x].emittance.g =
            (float)GameTextures[Terrain_tex_seg[Terrain_seg[seg].texseg_index].tex_index].g;
        Light_surfaces[i * 2 + x].emittance.b =
            (float)GameTextures[Terrain_tex_seg[Terrain_seg[seg].texseg_index].tex_index].b;

        Light_surfaces[i * 2 + x].roomnum = MAKE_ROOMNUM(seg);
        Light_surfaces[i * 2 + x].facenum = x;

        Light_surfaces[i * 2 + x].reflectivity =
            GameTextures[Terrain_tex_seg[Terrain_seg[seg].texseg_index].tex_index].reflectivity;
        Light_surfaces[i * 2 + x].xresolution = 1;
        Light_surfaces[i * 2 + x].yresolution = 1;
      }

      // Do upper left triangle
      Light_surfaces[i * 2].elements = mem_rmalloc<rad_element>();
      ASSERT(Light_surfaces[i * 2].elements != NULL);

      Light_surfaces[i * 2].elements[0].verts = mem_rmalloc<vector>(3);
      ASSERT(Light_surfaces[i * 2].elements[0].verts);

      Light_surfaces[i * 2].verts = mem_rmalloc<vector>(3);
      ASSERT(Light_surfaces[i * 2].verts != NULL);

      Light_surfaces[i * 2].normal = TerrainNormals[MAX_TERRAIN_LOD - 1][seg].normal1;

      z = i / (AREA_X);
      x = i % (AREA_X);

      a.x = x * TERRAIN_SIZE;
      a.y = Terrain_seg[(z * TERRAIN_WIDTH) + (x)].y;
      a.z = z * TERRAIN_SIZE;

      b.x = x * TERRAIN_SIZE;
      b.y = Terrain_seg[((z + 1) * TERRAIN_WIDTH) + (x)].y;
      b.z = (z + 1) * TERRAIN_SIZE;

      c.x = (x + 1) * TERRAIN_SIZE;
      c.y = Terrain_seg[((z + 1) * TERRAIN_WIDTH) + (x + 1)].y;
      c.z = (z + 1) * TERRAIN_SIZE;

      Light_surfaces[i * 2].verts[0] = a;
      Light_surfaces[i * 2].verts[1] = b;
      Light_surfaces[i * 2].verts[2] = c;
      Light_surfaces[i * 2].num_verts = 3;

      Light_surfaces[i * 2].elements[0].verts[0] = a;
      Light_surfaces[i * 2].elements[0].verts[1] = b;
      Light_surfaces[i * 2].elements[0].verts[2] = c;
      Light_surfaces[i * 2].elements[0].num_verts = 3;

      Light_surfaces[i * 2].elements[0].flags = 0;

      // Now do lower right

      Light_surfaces[i * 2 + 1].elements = mem_rmalloc<rad_element>();
      ASSERT(Light_surfaces[i * 2 + 1].elements != NULL);

      Light_surfaces[i * 2 + 1].elements[0].verts = mem_rmalloc<vector>(3);
      ASSERT(Light_surfaces[i * 2 + 1].elements[0].verts);

      Light_surfaces[i * 2 + 1].verts = mem_rmalloc<vector>(3);
      ASSERT(Light_surfaces[i * 2 + 1].verts != NULL);

      Light_surfaces[i * 2 + 1].normal = TerrainNormals[MAX_TERRAIN_LOD - 1][seg].normal2;

      z = i / (AREA_X);
      x = i % (AREA_X);

      a.x = x * TERRAIN_SIZE;
      a.y = Terrain_seg[(z * TERRAIN_WIDTH) + (x)].y;
      a.z = z * TERRAIN_SIZE;

      b.x = (x + 1) * TERRAIN_SIZE;
      b.y = Terrain_seg[((z + 1) * TERRAIN_WIDTH) + (x + 1)].y;
      b.z = (z + 1) * TERRAIN_SIZE;

      c.x = (x + 1) * TERRAIN_SIZE;
      c.y = Terrain_seg[(z * TERRAIN_WIDTH) + (x + 1)].y;
      c.z = z * TERRAIN_SIZE;

      Light_surfaces[i * 2 + 1].verts[0] = a;
      Light_surfaces[i * 2 + 1].verts[1] = b;
      Light_surfaces[i * 2 + 1].verts[2] = c;
      Light_surfaces[i * 2 + 1].num_verts = 3;

      Light_surfaces[i * 2 + 1].elements[0].verts[0] = a;
      Light_surfaces[i * 2 + 1].elements[0].verts[1] = b;
      Light_surfaces[i * 2 + 1].elements[0].verts[2] = c;
      Light_surfaces[i * 2 + 1].elements[0].num_verts = 3;

      Light_surfaces[i * 2 + 1].elements[0].flags = 0;
    }
  }

  // Setup satellites
  for (i = 0; i < Terrain_sky.num_satellites; i++, surf_index++) {
    Light_surfaces[surf_index].verts = mem_rmalloc<vector>(3);
    ASSERT(Light_surfaces[surf_index].verts != NULL);

    Light_surfaces[surf_index].elements = mem_rmalloc<rad_element>();
    ASSERT(Light_surfaces[surf_index].elements != NULL);

    Light_surfaces[surf_index].elements[0].verts = mem_rmalloc<vector>(3);
    ASSERT(Light_surfaces[surf_index].elements[0].verts);

    Light_surfaces[surf_index].surface_type = ST_SATELLITE;
    Light_surfaces[surf_index].emittance.r = Terrain_sky.satellite_r[i];
    Light_surfaces[surf_index].emittance.g = Terrain_sky.satellite_g[i];
    Light_surfaces[surf_index].emittance.b = Terrain_sky.satellite_b[i];

    Light_surfaces[surf_index].roomnum = i;
    Light_surfaces[surf_index].facenum = 0;

    Light_surfaces[surf_index].reflectivity = 0;
    Light_surfaces[surf_index].xresolution = 1;
    Light_surfaces[surf_index].yresolution = 1;

    vm_MakeZero(&Light_surfaces[surf_index].normal);

    Light_surfaces[surf_index].verts[0] = Terrain_sky.satellite_vectors[i];
    Light_surfaces[surf_index].verts[1] = Terrain_sky.satellite_vectors[i];
    Light_surfaces[surf_index].verts[2] = Terrain_sky.satellite_vectors[i];
    Light_surfaces[surf_index].num_verts = 3;

    Light_surfaces[surf_index].elements[0].verts[0] = Terrain_sky.satellite_vectors[i];
    Light_surfaces[surf_index].elements[0].verts[1] = Terrain_sky.satellite_vectors[i];
    Light_surfaces[surf_index].elements[0].verts[2] = Terrain_sky.satellite_vectors[i];
    Light_surfaces[surf_index].elements[0].num_verts = 3;

    Light_surfaces[surf_index].elements[0].flags = 0;
  }

  // Setup external rooms

  room_surf_start = surf_index;
  for (i = 0; i < MAX_ROOMS; i++) {
    if (Rooms[i].used) {
      if (!(Rooms[i].flags & RF_EXTERNAL))
        continue;

      for (t = 0; t < Rooms[i].num_faces; t++, surf_index++) {

        ComputeSurfaceRes(&Light_surfaces[surf_index], &Rooms[i], t);

        Light_surfaces[surf_index].verts = mem_rmalloc<vector>(Rooms[i].faces[t].num_verts);
        ASSERT(Light_surfaces[surf_index].verts != NULL);

        Light_surfaces[surf_index].elements = mem_rmalloc<rad_element>(
            Light_surfaces[surf_index].xresolution * Light_surfaces[surf_index].yresolution);
        ASSERT(Light_surfaces[surf_index].elements != NULL);

        if (Rooms[i].faces[t].portal_num != -1 &&
            !(Rooms[i].portals[Rooms[i].faces[t].portal_num].flags & PF_RENDER_FACES))

        {
          Light_surfaces[surf_index].surface_type = ST_PORTAL;
          Light_surfaces[surf_index].emittance.r = 0;
          Light_surfaces[surf_index].emittance.g = 0;
          Light_surfaces[surf_index].emittance.b = 0;
        } else {
          float mul = ((float)Rooms[i].faces[t].light_multiple) / 4.0;
          mul *= GlobalMultiplier * Room_multiplier[i];

          Light_surfaces[surf_index].emittance.r = (float)GameTextures[Rooms[i].faces[t].tmap].r * mul;
          Light_surfaces[surf_index].emittance.g = (float)GameTextures[Rooms[i].faces[t].tmap].g * mul;
          Light_surfaces[surf_index].emittance.b = (float)GameTextures[Rooms[i].faces[t].tmap].b * mul;
          Light_surfaces[surf_index].surface_type = ST_EXTERNAL_ROOM;

          // if ((GetMaxColor (&Light_surfaces[surf_index].emittance))>.005)
          //	Light_surfaces[surf_index].flags|=SF_LIGHTSOURCE;
        }

        Light_surfaces[surf_index].normal = LightmapInfo[Rooms[i].faces[t].lmi_handle].normal;
        Light_surfaces[surf_index].roomnum = i;
        Light_surfaces[surf_index].facenum = t;

        Light_surfaces[surf_index].reflectivity = GameTextures[Rooms[i].faces[t].tmap].reflectivity;

        // Set the vertices for each element
        BuildElementListForRoomFace(i, t, &Light_surfaces[surf_index]);

        int xres = Light_surfaces[surf_index].xresolution;
        int yres = Light_surfaces[surf_index].yresolution;
      }
    }
  }

  // Setup objects
  obj_surf_start = surf_index;
  ComputeSurfacesForObjects(surf_index, 1);

  mprintf(0, "Solving radiosity equation (press tilde key to stop)...\n");

  if (D3EditState.hemicube_radiosity)
    DoRadiosityRun(SM_SWITCH_AFTER_SATELLITES, Light_surfaces, total_surfaces);
  else
    DoRadiosityRun(SM_RAYCAST, Light_surfaces, total_surfaces);

  // Figure out lighting by averaging the two triangles per terrain cell

  if (!Ignore_terrain) {
    for (i = 0; i < AREA_X * AREA_Z; i++) {
      // Add in ambient terrain light
      terrain_sums[0][i].r = std::min(1.0f, Light_surfaces[i * 2].elements[0].exitance.r + Ambient_red);
      terrain_sums[0][i].g = std::min(1.0f, Light_surfaces[i * 2].elements[0].exitance.g + Ambient_green);
      terrain_sums[0][i].b = std::min(1.0f, Light_surfaces[i * 2].elements[0].exitance.b + Ambient_blue);

      terrain_sums[1][i].r = std::min(1.0f, Light_surfaces[i * 2 + 1].elements[0].exitance.r + Ambient_red);
      terrain_sums[1][i].g = std::min(1.0f, Light_surfaces[i * 2 + 1].elements[0].exitance.g + Ambient_green);
      terrain_sums[1][i].b = std::min(1.0f, Light_surfaces[i * 2 + 1].elements[0].exitance.b + Ambient_blue);
    }

    for (i = 0; i < (AREA_X) * (AREA_Z); i++) {
      int x, z;
      spectra total;
      int num_items = 0;
      int seg;

      memset(&total, 0, sizeof(spectra));

      x = i % (AREA_X);
      z = i / (AREA_Z);

      seg = z * TERRAIN_WIDTH + x;

      if (x != 0) {
        AddSpectra(&total, &total, &terrain_sums[1][z * (AREA_X) + (x - 1)]);
        num_items++;
      }

      AddSpectra(&total, &total, &terrain_sums[0][z * (AREA_X) + x]);
      AddSpectra(&total, &total, &terrain_sums[1][z * (AREA_X) + x]);

      num_items += 2;

      if (x != 0) {
        if (z != 0) {
          AddSpectra(&total, &total, &terrain_sums[0][(z - 1) * (AREA_X) + (x - 1)]);
          AddSpectra(&total, &total, &terrain_sums[1][(z - 1) * (AREA_X) + (x - 1)]);
          num_items += 2;
        }
      }

      if (z != 0) {

        AddSpectra(&total, &total, &terrain_sums[0][(z - 1) * (AREA_X) + x]);
        num_items++;
      }

      total.r /= num_items;
      total.g /= num_items;
      total.b /= num_items;

      if (total.r > 1.0)
        total.r = 1.0;
      if (total.g > 1.0)
        total.g = 1.0;
      if (total.b > 1.0)
        total.b = 1.0;

      Terrain_seg[seg].l = Float_to_ubyte(GetMaxColor(&total));

      Terrain_seg[seg].r = Float_to_ubyte(total.r);
      Terrain_seg[seg].g = Float_to_ubyte(total.g);
      Terrain_seg[seg].b = Float_to_ubyte(total.b);
    }
  }

  // Assign lightmaps to external rooms
  for (i = 0; i < MAX_ROOMS; i++) {
    if (Rooms[i].used) {
      if (!(Rooms[i].flags & RF_EXTERNAL))
        continue;

      for (t = 0; t < Rooms[i].num_faces; t++, room_surf_start++) {
        AssignRoomSurfaceToLightmap(i, t, &Light_surfaces[room_surf_start]);
      }
    }
  }

  // Now assign lightmaps to objects
  AssignLightmapsToObjectSurfaces(obj_surf_start, 1);

  // Shade room/object lightmaps

  BlurLightmapInfos(LMI_EXTERNAL_ROOM);
  BlurLightmapInfos(LMI_TERRAIN_OBJECT);

  ShadeLightmapInfoEdges(LMI_EXTERNAL_ROOM);
  ShadeLightmapInfoEdges(LMI_TERRAIN_OBJECT);

  // Free memory

  for (i = 0; i < total_surfaces; i++) {
    mem_free(Light_surfaces[i].verts);
    for (int t = 0; t < Light_surfaces[i].xresolution * Light_surfaces[i].yresolution; t++)
      if (Light_surfaces[i].elements[t].num_verts > 0)
        mem_free(Light_surfaces[i].elements[t].verts);
    mem_free(Light_surfaces[i].elements);
  }

  mem_free(Light_surfaces);
  mem_free(terrain_sums[0]);
  mem_free(terrain_sums[1]);

  for (i = 0; i < Terrain_sky.num_satellites; i++)
    mem_free(TerrainLightSpeedup[i]);

  UpdateTerrainLightmaps();
  SqueezeLightmaps(1, -1);
  // Figure out combined portals
  CheckCombinePortals(1);

  if (do_dynamic)
    DoTerrainDynamicTable();

  OutrageMessageBox(
      "Terrain radiosity complete!\nIt is recommended you save the level so you won't have to rerun this operation.");
}
/*
void DoRadiosityForTerrain ()
{
        int i,t,j,maxrays;
        int raynum=0;
        spectra *exitance;
        int lit=0;
        int do_dynamic=0;

        if ((MessageBox(NULL,"Do you wish to calculate dynamic terrain lighting when radiosity is completed? (Note:
Dynamic lighting takes a long time)","Question",MB_YESNO))==IDYES) do_dynamic=1;

        // First make sure there is even a light source
        for (i=0;i<Terrain_sky.num_satellites;i++)
        {
                int tmap=Terrain_sky.satellite_texture[i];
                if (GameTextures[tmap].r>0 || GameTextures[tmap].g || GameTextures[tmap].b)
                        lit=1;
        }

        if (!lit)
        {
                OutrageMessageBox ("No moons/suns cast light so there is no point in running terrain radiosity!");
                return;
        }

        maxrays=(TERRAIN_DEPTH-1)*(TERRAIN_WIDTH-1)*Terrain_sky.num_satellites;

        mprintf(0,"Calculating terrain radiosity for %d points! (be patient!)\n",maxrays);

        // Malloc some memory
        exitance=(spectra *)mem_malloc (TERRAIN_DEPTH*TERRAIN_WIDTH*sizeof(spectra));
        ASSERT (exitance!=NULL);

        for (i=0;i<TERRAIN_DEPTH*TERRAIN_WIDTH;i++)
        {
                exitance[i].r=0;
                exitance[i].g=0;
                exitance[i].b=0;
        }

        // Now shoot a ray from every triangle on the terrain to every moon/sun in the
        // sky, tallying the results
        for (i=0;i<TERRAIN_DEPTH-1;i++)
        {
                for (t=0;t<TERRAIN_WIDTH-1;t++)
                {
                        int tseg=i*TERRAIN_WIDTH+t;
                        vector pos1,pos2;

                        pos1.x=(t*TERRAIN_SIZE)+(TERRAIN_SIZE/3);
                        pos1.z=(i*TERRAIN_SIZE)+(TERRAIN_SIZE * .66);
                        pos1.y=GetTerrainGroundPoint (&pos1);
                        pos1+=((TerrainNormals[MAX_TERRAIN_LOD-1][tseg].normal1)/16);

                        pos2.x=(t*TERRAIN_SIZE)+(TERRAIN_SIZE * .66);
                        pos2.z=(i*TERRAIN_SIZE)+(TERRAIN_SIZE/3);
                        pos2.y=GetTerrainGroundPoint (&pos2);
                        pos2+=((TerrainNormals[MAX_TERRAIN_LOD-1][tseg].normal2)/16);

                        for (j=0;j<Terrain_sky.num_satellites;j++)
                        {
                                raynum++;

                                int answer1,answer2;
                                answer1=ShootRayForTerrainLight (&pos1,&Terrain_sky.satellite_vectors[j],tseg);
                                answer2=ShootRayForTerrainLight (&pos2,&Terrain_sky.satellite_vectors[j],tseg);

                                if (answer1==0 && answer2==0)
                                        continue;

                                float r=exitance[tseg].r;
                                float g=exitance[tseg].g;
                                float b=exitance[tseg].b;
                                int tmap=Terrain_sky.satellite_texture[j];

                                float light1,light2,light_avg;
                                vector tnorm1=TerrainNormals[MAX_TERRAIN_LOD-1][tseg].normal1;
                                vector tnorm2=TerrainNormals[MAX_TERRAIN_LOD-1][tseg].normal2;

                                vector normal;

                                vm_GetNormalizedDir (&normal,&Terrain_sky.satellite_vectors[j],&pos1);
                                light1=answer1*(vm_DotProduct (&normal,&tnorm1));
                                if (light1<0)
                                        light1=0;

                                vm_GetNormalizedDir (&normal,&Terrain_sky.satellite_vectors[j],&pos2);
                                light2=answer2*(vm_DotProduct (&normal,&tnorm2));
                                if (light2<0)
                                        light2=0;

                                light_avg=(light1+light2)/2;

                                r+=(light_avg*GameTextures[tmap].r);
                                g+=(light_avg*GameTextures[tmap].g);
                                b+=(light_avg*GameTextures[tmap].b);

                                exitance[tseg].r=r;
                                exitance[tseg].g=g;
                                exitance[tseg].b=b;
                        }
                }
        }

        // Clip to 1.0
        for (i=0;i<TERRAIN_DEPTH*TERRAIN_WIDTH;i++)
        {
                exitance[i].r=std::min(exitance[i].r,1.0f);
                exitance[i].g=std::min(exitance[i].g,1.0f);
                exitance[i].b=std::min(exitance[i].b,1.0f);
        }


        // Now average the surrounding cells to get a 'smooth' shadow effect
        for (i=0;i<TERRAIN_DEPTH;i++)
        {
                for (t=0;t<TERRAIN_WIDTH;t++)
                {
                        int tseg=i*TERRAIN_WIDTH+t;
                        spectra total={0,0,0};
                        int num=0;

                        AddSpectra (&total,&total,&exitance[tseg]);
                        num++;

                        if (i!=0)
                        {
                                AddSpectra (&total,&total,&exitance[(i-1)*TERRAIN_WIDTH+t]);
                                num++;
                                if (t!=0)
                                {
                                        AddSpectra (&total,&total,&exitance[(i-1)*TERRAIN_WIDTH+(t-1)]);
                                        num++;
                                }

                        }
                        if (t!=0)
                        {
                                AddSpectra (&total,&total,&exitance[i*TERRAIN_WIDTH+(t-1)]);
                                num++;
                        }

                        total.r/=num;
                        total.g/=num;
                        total.b/=num;

                        Terrain_seg[tseg].r=total.r*255;
                        Terrain_seg[tseg].g=total.g*255;
                        Terrain_seg[tseg].b=total.b*255;
                        Terrain_seg[tseg].l=((total.r+total.g+total.b)*255)/3;
                }
        }

        free (exitance);

        if (do_dynamic)
                DoTerrainDynamicTable();

        UpdateTerrainLightmaps();
        OutrageMessageBox ("Terrain radiosity complete!\nIt is recommended you save the level so you won't have to rerun
this operation.");

}*/

void BuildLightmapUVs(int *room_list, int *face_list, int count, vector *lightmap_poly, int nv, int external) {
  matrix face_matrix, trans_matrix;
  vector fvec;
  vector avg_vert;
  vector verts[MAX_VERTS_PER_FACE * 5];
  vector facevert;
  vector rot_vert;
  int i, t;
  int lmi_handle;

  // find the center point of this face
  vm_MakeZero(&avg_vert);
  for (i = 0; i < nv; i++)
    avg_vert += lightmap_poly[i];

  avg_vert /= nv;

  // Make the orientation matrix
  // Reverse the normal because we're looking "at" the face, not from it
  fvec = -Rooms[room_list[0]].faces[face_list[0]].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 < nv; i++) {
    vector vert = lightmap_poly[i];

    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 < nv; i++) {
    if (verts[i].x < leftmost_x) {
      leftmost_point = i;
      leftmost_x = verts[i].x;
    }
  }

  ASSERT(leftmost_point != -1);

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

  for (i = 0; i < nv; i++) {
    if (verts[i].y > topmost_y) {
      topmost_point = i;
      topmost_y = verts[i].y;
    }
  }

  ASSERT(topmost_point != -1);

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

  for (i = 0; i < nv; i++) {
    if (verts[i].x > rightmost_x) {
      rightmost_point = i;
      rightmost_x = verts[i].x;
    }
  }

  ASSERT(rightmost_point != -1);

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

  for (i = 0; i < nv; i++) {
    if (verts[i].y < bottommost_y) {
      bottommost_point = i;
      bottommost_y = verts[i].y;
    }
  }

  ASSERT(bottommost_point != -1);

  // now set the base vertex, which is where we base uv 0,0 on

  vector base_vector;

  base_vector.x = verts[leftmost_point].x;
  base_vector.y = verts[topmost_point].y;
  base_vector.z = 0;

  // Figure out lightmap resolution
  float xdiff = verts[rightmost_point].x - verts[leftmost_point].x;
  float ydiff = verts[topmost_point].y - verts[bottommost_point].y;
  float max_diff = (float)std::max(xdiff, ydiff);

  int lightmap_x_res = -1, lightmap_y_res = -1;
  float xspacing = LightSpacing;
  float yspacing = LightSpacing;
  float spacing = LightSpacing;
  int res, done_spacing = 0;
  int xspace_int, yspace_int;

  // If the default spacing would make us go over our lightmap resolution
  // limit, then increase the spacing and try again
  while (!done_spacing) {
    res = (xdiff / xspacing);
    if (((xdiff / xspacing) - res) > 0)
      res++;

    res++;

    if (res > 126)
      xspacing += 1;
    else
      done_spacing = 1;
  }

  // Set a mininum, at least
  if (res < 2)
    res = 2;

  lightmap_x_res = res;

  done_spacing = 0;
  while (!done_spacing) {
    res = (ydiff / yspacing);
    if (((ydiff / yspacing) - res) > 0)
      res++;

    res++;

    if (res > 126)
      yspacing += 1;
    else
      done_spacing = 1;
  }

  // Set a mininum, at least
  if (res < 2)
    res = 2;

  lightmap_y_res = res;

  /*// Find power of 2 number
  for (i=0;i<=7;i++)
  {
          int low_num=1<i;
          int hi_num=2<<i;
          if (res<=hi_num && res>low_num)
          {
                  lightmap_res=hi_num;
                  break;
          }
  }*/

  if (external)
    lmi_handle = AllocLightmapInfo(lightmap_x_res, lightmap_y_res, LMI_EXTERNAL_ROOM);
  else
    lmi_handle = AllocLightmapInfo(lightmap_x_res, lightmap_y_res, LMI_ROOM);

  ASSERT(lmi_handle != BAD_LMI_INDEX);
  ASSERT(lmi_handle >= 0 && lmi_handle <= MAX_LIGHTMAP_INFOS);
  Lightmaps_for_rad++;

  // Now do best fit spacing
  if (BestFit) {
    xspace_int = (xdiff / lightmap_x_res);
    if ((xdiff - (lightmap_x_res * xspace_int)) > 0)
      xspace_int++;

    yspace_int = (ydiff / lightmap_y_res);
    if ((ydiff - (lightmap_y_res * yspace_int)) > 0)
      yspace_int++;
  } else {
    xspace_int = xspacing;
    yspace_int = yspacing;
  }

  // Figure out lightmap uvs

  // Rotate all the face points
  for (i = 0; i < count; i++) {
    Rooms[room_list[i]].faces[face_list[i]].lmi_handle = lmi_handle;

    for (t = 0; t < Rooms[room_list[i]].faces[face_list[i]].num_verts; t++) {
      room *rp = &Rooms[room_list[i]];
      face *fp = &rp->faces[face_list[i]];
      vector vert = rp->verts[fp->face_verts[t]];

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

      facevert = rot_vert;

      // Find uv2s for this vertex
      fp->face_uvls[t].u2 = (facevert.x - verts[leftmost_point].x) / (float)(lightmap_x_res * xspace_int);
      fp->face_uvls[t].v2 = fabs((verts[topmost_point].y - facevert.y)) / (float)(lightmap_y_res * yspace_int);

      if (fp->face_uvls[t].u2 < 0)
        fp->face_uvls[t].u2 = 0;
      if (fp->face_uvls[t].v2 < 0)
        fp->face_uvls[t].v2 = 0;

      ASSERT(fp->face_uvls[t].u2 >= 0 && fp->face_uvls[t].u2 <= 1.0);
      ASSERT(fp->face_uvls[t].v2 >= 0 && fp->face_uvls[t].v2 <= 1.0);
    }
  }

  // Find upper left corner
  vm_TransposeMatrix(&trans_matrix);
  vm_MatrixMulVector(&rot_vert, &base_vector, &trans_matrix);
  LightmapInfo[lmi_handle].upper_left = rot_vert + avg_vert;

  LightmapInfo[lmi_handle].xspacing = xspace_int;
  LightmapInfo[lmi_handle].yspacing = yspace_int;
  LightmapInfo[lmi_handle].normal = Rooms[room_list[0]].faces[face_list[0]].normal;
  ScratchCenters[lmi_handle] = avg_vert;
}

#define MAX_COMBINES 50
#define LM_ADJACENT_FACE_THRESHOLD .999
uint8_t *RoomsAlreadyCombined[MAX_ROOMS];

/*
// Returns number of verts in dest if face a can be safely combined with face b
// Returns 0 if not
int CombineLightFaces( vector *dest_verts,vector *averts, int nva, vector *norma,vector *bverts, int nvb,vector
*normb,int aroom,int broom)
{
        int starta, startb, i;
        vector va;
        float dp;

        dp=vm_DotProduct (normb,norma);

        if (dp < LM_ADJACENT_FACE_THRESHOLD)
                return 0;

        ASSERT (nva > 2 );
        ASSERT (nvb > 2 );

        // Go through each vertex and get a match

        for (starta=0; starta<nva; starta++ )
        {
                int nexta=(starta+1)%nva;

                for (startb=0; startb<nvb; startb++ )
                {
                        int nextb=(startb+1)%nvb;

                        if ((PointsAreSame (&averts[starta],&bverts[nextb])) &&
                                  (PointsAreSame(&averts[nexta],&bverts[startb])))
                        {
                                //MATCH!!!!!!!!

                                int dnv = 0;

                                for (i=1; i<nva; i++ )
                                {
                                        ASSERT(dnv < MAX_VERTS_PER_FACE*5);
                                        dest_verts[dnv] = averts[(starta+i)%nva];
                                        va = dest_verts[dnv];
                                        dnv++;
                                }

                                if ( (PointsAreSame(&va,&bverts[(startb+2)%nvb])))
                                        mprintf(0, "WARNING!!! Faces were combined that caused the loss of a
vertex!\n");

                                for (i=1; i<nvb; i++ )
                                {
                                        ASSERT(dnv < MAX_VERTS_PER_FACE*5 );
                                        if ( (i==1) && (PointsAreSame(&va,&bverts[(startb+i+1)%nvb])))
                                                continue;
                                        else if ( (i==2) && (PointsAreSame(&va,&bverts[(startb+i)%nvb])))
                                                continue;
                                        else
                                        {
                                                dest_verts[dnv] = bverts[(startb+i)%nvb];
                                                dnv++;

                                        }
                                }
                                ASSERT( dnv > 2 );

                                return dnv;
                        }
                }
        }

         Now check for tjoint faces
        for (starta=0; starta<nva; starta++)
        {
                int nexta=(starta+1)%nva;

                for (startb=0; startb<nvb; startb++)
                {
                        vector line_a=averts[nexta]-averts[starta];



                }
        }

        // If these two faces are in the same room and are on the same plane
        // then we should combine them by default

        if (aroom!=-1 && aroom==broom)
        {
                int dnv = 0;
                int match=0;

                // Test to see if any points at all can touch

                for (i=0; i<nva && !match; i++ )
                {
                        for (int t=0; t<nvb && !match; t++ )
                        {
                                if (PointsAreSame(&averts[i],&bverts[t]))
                                        match=1;
                        }
                }

                if (!match)
                        return 0;

                // At least one point is the same, so combine them!
                for (i=0; i<nva; i++ )
                {
                        dest_verts[dnv] = averts[i];
                        dnv++;
                        ASSERT(dnv < MAX_VERTS_PER_FACE * 5);
                }

                for (i=0; i<nvb; i++ )
                {
                        dest_verts[dnv] = bverts[i];
                        dnv++;
                        ASSERT(dnv < MAX_VERTS_PER_FACE * 5);
                }

                return dnv;
        }

        return 0;
}*/

// Returns number of verts in dest if face a can be safely combined with face b
// Returns 0 if not
int CombineLightFaces(vector *dest_verts, vector *averts, int nva, vector *norma, vector *bverts, int nvb,
                      vector *normb, int aroom, int broom) {
  int i;

  float dp;

  dp = vm_DotProduct(normb, norma);

  if (dp < LM_ADJACENT_FACE_THRESHOLD)
    return 0;

  ASSERT(nva > 2);
  ASSERT(nvb > 2);

  // Go through each vertex and get a match

  // If these two faces are in the same room and are on the same plane
  // then we should combine them by default

  if (1 || (aroom != -1 && aroom == broom)) {
    int dnv = 0;
    int match = 0;

    // Don't go over our point limit
    if ((nva + nvb) >= (MAX_VERTS_PER_FACE * 5))
      return 0;

    // Test to see if any points at all can touch

    for (i = 0; i < nva && !match; i++) {
      for (int t = 0; t < nvb && !match; t++) {
        if (PointsAreSame(&averts[i], &bverts[t]))
          match = 1;
      }
    }

    if (!match)
      return 0;

    // At least one point is the same, so combine them!
    for (i = 0; i < nva; i++) {
      dest_verts[dnv] = averts[i];
      dnv++;
      ASSERT(dnv < MAX_VERTS_PER_FACE * 5);
    }

    for (i = 0; i < nvb; i++) {
      dest_verts[dnv] = bverts[i];
      dnv++;
      ASSERT(dnv < MAX_VERTS_PER_FACE * 5);
    }

    return dnv;
  }

  return 0;
}

// Given a roomnumber and a face, goes through the entire mine and checks to see
// if this face can share a lightmap with any other face
int TestLightAdjacency(int roomnum, int facenum, int external) {

  int i, t, k;
  room *arp = &Rooms[roomnum];
  face *afp = &arp->faces[facenum];

  vector averts[MAX_VERTS_PER_FACE * 5];
  vector bverts[MAX_VERTS_PER_FACE * 5];
  vector dest_verts[MAX_VERTS_PER_FACE * 5];

  int face_combine_list[MAX_COMBINES];
  int room_combine_list[MAX_COMBINES];

  ASSERT(roomnum >= 0 && roomnum < MAX_ROOMS);

  if (!AllowCombining)
    return 0;

  // if (GameTextures[afp->tmap].r>0 || GameTextures[afp->tmap].g>0 || GameTextures[afp->tmap].b>0)
  //	return 0;

  // Don't combine portals!
  if (afp->portal_num != -1)
    return 0;

  // Setup our 'base' face

  int anv = afp->num_verts;
  int total_faces = 1;

  room_combine_list[0] = roomnum;
  face_combine_list[0] = facenum;

  for (i = 0; i < afp->num_verts; i++)
    averts[i] = arp->verts[afp->face_verts[i]];

StartOver:

  // Go through each room and find an adjacent face
  for (i = roomnum; i < MAX_ROOMS; i++) {
    if (!Rooms[i].used)
      continue;

    if (Rooms[i].flags & RF_NO_LIGHT)
      continue;

    if (external && !(Rooms[i].flags & RF_EXTERNAL))
      continue;

    if (!external && (Rooms[i].flags & RF_EXTERNAL))
      continue;

    /*if (i!=roomnum) // Only combine faces in the same room
            continue;*/

    for (t = 0; t < Rooms[i].num_faces; t++) {
      if (total_faces >= MAX_COMBINES - 1)
        continue;

      if (&Rooms[i] == arp && t == facenum)
        continue; // don't do self

      // Don't do if already spoken fore
      if (RoomsAlreadyCombined[i][t])
        continue;

      room *brp = &Rooms[i];
      face *bfp = &brp->faces[t];

      // Don't do combine light sources
      // if (GameTextures[bfp->tmap].r>0 || GameTextures[bfp->tmap].g>0 || GameTextures[bfp->tmap].b>0)
      //	continue;
      // Don't combine portals!
      if (bfp->portal_num != -1)
        continue;

      for (k = 0; k < bfp->num_verts; k++)
        bverts[k] = brp->verts[bfp->face_verts[k]];

      int nv =
          CombineLightFaces(dest_verts, averts, anv, &afp->normal, bverts, bfp->num_verts, &bfp->normal, roomnum, i);

      // We have a combine!  Mark this face in the appropriate list
      // And update our new polygon
      if (nv > 0) {
        room_combine_list[total_faces] = i;
        face_combine_list[total_faces] = t;
        total_faces++;

        RoomsAlreadyCombined[roomnum][facenum] = 1;
        RoomsAlreadyCombined[i][t] = 1;
        for (k = 0; k < nv; k++)
          averts[k] = dest_verts[k];

        anv = nv;

        goto StartOver;
      }
    }
  }

  // Now build 1 lightmap to be shared across all the faces that were combined
  if (total_faces > 1) {
    BuildLightmapUVs(room_combine_list, face_combine_list, total_faces, averts, anv, external);
  }

  return 1;
}

// Computes the the mines UVs
// Faces can now share one lightmap, so this routine goes through and tries to
// combine as many faces as it can into one lightmap
void ComputeAllRoomLightmapUVs(int external) {
  int i, t, k;
  int not_combined = 0;

  for (i = 0; i < MAX_ROOMS; i++) {
    if (Rooms[i].used) {
      if (Rooms[i].flags & RF_NO_LIGHT)
        continue;

      if (external && !(Rooms[i].flags & RF_EXTERNAL))
        continue;

      if (!external && (Rooms[i].flags & RF_EXTERNAL))
        continue;

      RoomsAlreadyCombined[i] = mem_rmalloc<uint8_t>(Rooms[i].num_faces);
      ASSERT(RoomsAlreadyCombined[i]);
      for (k = 0; k < Rooms[i].num_faces; k++)
        RoomsAlreadyCombined[i][k] = 0;
    }
  }

  for (i = 0; i < MAX_ROOMS; i++) {
    if (Rooms[i].used) {
      if (Rooms[i].flags & RF_NO_LIGHT)
        continue;

      if (external && !(Rooms[i].flags & RF_EXTERNAL))
        continue;

      if (!external && (Rooms[i].flags & RF_EXTERNAL))
        continue;

      for (t = 0; t < Rooms[i].num_faces; t++) {
        if (*(RoomsAlreadyCombined[i] + t) == 0)
          TestLightAdjacency(i, t, external);
      }
    }
  }

  // Now build lightmaps for any faces that couldn't be combined
  for (i = 0; i < MAX_ROOMS; i++) {
    if (Rooms[i].used) {
      if (Rooms[i].flags & RF_NO_LIGHT)
        continue;

      if (external && !(Rooms[i].flags & RF_EXTERNAL))
        continue;

      if (!external && (Rooms[i].flags & RF_EXTERNAL))
        continue;

      for (t = 0; t < Rooms[i].num_faces; t++) {
        if (!RoomsAlreadyCombined[i][t]) {
          vector verts[MAX_VERTS_PER_FACE * 5];
          int room_list[2], face_list[2];
          for (k = 0; k < Rooms[i].faces[t].num_verts; k++)
            verts[k] = Rooms[i].verts[Rooms[i].faces[t].face_verts[k]];

          room_list[0] = i;
          face_list[0] = t;

          BuildLightmapUVs(room_list, face_list, 1, verts, Rooms[i].faces[t].num_verts, external);
          not_combined++;
        }
      }
    }
  }

  mprintf(0, "%d faces couldn't be combined!\n", not_combined);

  // Free memory
  for (i = 0; i < MAX_ROOMS; i++) {
    if (Rooms[i].used) {
      if (Rooms[i].flags & RF_NO_LIGHT)
        continue;

      if (external && !(Rooms[i].flags & RF_EXTERNAL))
        continue;

      if (!external && (Rooms[i].flags & RF_EXTERNAL))
        continue;

      mem_free(RoomsAlreadyCombined[i]);
    }
  }
}

//	Returns number preceding val modulo modulus.
//	prevmod(3,4) = 2
//	prevmod(0,4) = 3
int SpecularPrevIndex(int val, int modulus) {
  if (val > 0)
    return val - 1;
  else
    return modulus - 1;
}

//	Returns number succeeding val modulo modulus.
//	succmod(3,4) = 0
//	succmod(0,4) = 1
int SpecularNextIndex(int val, int modulus) {
  if (val < modulus - 1)
    return val + 1;
  else
    return 0;
}

// Gets the left top, left bottom, right top, and right bottom indices.  Also finds
// lowest y index.
void GetSpecularVertexOrdering(spec_vertex *verts, int nv, int *vlt, int *vlb, int *vrt, int *vrb, int *bottom_y_ind) {
  int i;
  float min_y, max_y;
  int min_y_ind;
  int original_vrt;
  float min_x;

  // Scan all vertices, set min_y_ind to vertex with smallest y coordinate.
  min_y = verts[0].y;
  max_y = min_y;
  min_y_ind = 0;
  min_x = verts[0].x;
  *bottom_y_ind = 0;

  for (i = 1; i < nv; i++) {
    if (verts[i].y < min_y) {
      min_y = verts[i].y;
      min_y_ind = i;
      min_x = verts[i].x;
    } else if (verts[i].y == min_y) {
      if (verts[i].x < min_x) {
        min_y_ind = i;
        min_x = verts[i].x;
      }
    }
    if (verts[i].y > max_y) {
      max_y = verts[i].y;
      *bottom_y_ind = i;
    }
  }

  // Set "vertex left top", etc. based on vertex with topmost y coordinate
  *vlt = min_y_ind;
  *vrt = *vlt;
  *vlb = SpecularPrevIndex(*vlt, nv);
  *vrb = SpecularNextIndex(*vrt, nv);

  // If right edge is horizontal, then advance along polygon bound until it no longer is or until all
  // vertices have been examined.
  // (Left edge cannot be horizontal, because *vlt is set to leftmost point with highest y coordinate.)

  original_vrt = *vrt;

  while (verts[*vrt].y == verts[*vrb].y) {
    if (SpecularNextIndex(*vrt, nv) == original_vrt)
      break;

    *vrt = SpecularNextIndex(*vrt, nv);
    *vrb = SpecularNextIndex(*vrt, nv);
  }
}

/*
// Creates a map that contains all the interpolated normals for a particular face
// Used in specular mapping
void CreateNormalMapForFace (room *rp,face *fp)
{
        int w=lmi_w(fp->lmi_handle);
        int h=lmi_h(fp->lmi_handle);
        special_face *sfp=&SpecialFaces[fp->special_handle];
        spec_vertex spec_verts[MAX_VERTS_PER_FACE];
        vector vertnorms[MAX_VERTS_PER_FACE];
        int vlt,vlb,vrt,vrb,max_y_vertex,top_y,bottom_y,height;
        int no_height=0,no_width=0,no_right=0,no_left=0;
        lightmap_info *lmi_ptr=&LightmapInfo[fp->lmi_handle];
        uint16_t *src_data=lm_data(lmi_ptr->lm_handle);

        matrix facematrix;
        vector fvec=-lmi_ptr->normal;
        vm_VectorToMatrix(&facematrix,&fvec,NULL,NULL);

        sfp->normal_map=(uint8_t *)mem_malloc (w*h*3);
        ASSERT (sfp->normal_map);

        for (int i=0;i<(w*h);i++)
        {
                sfp->normal_map[i*3+0]=0;
                sfp->normal_map[i*3+1]=0;
                sfp->normal_map[i*3+2]=128;
        }

        for (i=0;i<fp->num_verts;i++)
        {
                vm_MatrixMulVector (&vertnorms[i],&sfp->vertnorms[i],&facematrix);
                spec_verts[i].x=fp->face_uvls[i].u2;
                spec_verts[i].y=fp->face_uvls[i].v2;
        }

        GetSpecularVertexOrdering(spec_verts,fp->num_verts,&vlt,&vlb,&vrt,&vrb,&max_y_vertex);

        top_y=spec_verts[vlt].y*h;
        bottom_y=spec_verts[max_y_vertex].y*h;

        height = bottom_y-top_y;
   if(height == 0)
                no_height=1;

        // Setup left interpolant
        int left_height=((spec_verts[vlb].y-spec_verts[vlt].y)*(float)h);

        float left_x=spec_verts[vlt].x*w;
        float delta_left_x=((spec_verts[vlb].x-spec_verts[vlt].x)*w)/left_height;
        vector left_vnorm=vertnorms[vlt];
        vector delta_left_vnorm=(vertnorms[vlb]-vertnorms[vlt])/left_height;
        int next_break_left = spec_verts[vlb].y*h;

        // Setup right interpolant

        int right_height=((spec_verts[vrb].y-spec_verts[vrt].y)*(float)h);

        float right_x=spec_verts[vrt].x*w;
        float delta_right_x=((spec_verts[vrb].x-spec_verts[vrt].x)*w)/right_height;
        vector right_vnorm=vertnorms[vrt];
        vector delta_right_vnorm=(vertnorms[vrb]-vertnorms[vrt])/right_height;
        int next_break_right = spec_verts[vrb].y*h;

        // Do the loop
        for (int y=top_y;y<=bottom_y;y++)
        {
                if (y==next_break_left && !no_height)
                {
                        while (y == (int)(spec_verts[vlb].y*h))
                        {
                                vlt = vlb;
                                vlb = SpecularPrevIndex(vlb,fp->num_verts);
                        }

                        // Setup left interpolant
                        left_height=((spec_verts[vlb].y-spec_verts[vlt].y)*(float)h);
                        left_x=spec_verts[vlt].x*w;
                        delta_left_x=((spec_verts[vlb].x-spec_verts[vlt].x)*w)/left_height;
                        left_vnorm=vertnorms[vlt];
                        delta_left_vnorm=(vertnorms[vlb]-vertnorms[vlt])/left_height;
                        next_break_left = spec_verts[vlb].y*h;

                }

                if (y==next_break_right && !no_height)
                {
                        while (y == (int)(spec_verts[vrb].y*h))
                        {
                                vrt = vrb;
                                vrb = SpecularNextIndex(vrb,fp->num_verts);
                        }
                        right_height=((spec_verts[vrb].y-spec_verts[vrt].y)*(float)h);
                        right_x=spec_verts[vrt].x*w;
                        delta_right_x=((spec_verts[vrb].x-spec_verts[vrt].x)*w)/right_height;
                        right_vnorm=vertnorms[vrt];
                        delta_right_vnorm=(vertnorms[vrb]-vertnorms[vrt])/right_height;
                        next_break_right = spec_verts[vrb].y*h;
                }

                int width=(right_x-left_x)+1;

                vector delta_vnorm=(right_vnorm-left_vnorm)/width;
                vector vnorm=left_vnorm;

                for (i=left_x;i<(left_x+width);i++)
                {
                        int offset=y*w+i;

                        if (!(src_data[offset] & OPAQUE_FLAG))
                                continue;

                        sfp->normal_map[(offset*3)+0]=((vnorm.x+1.0)/2.0)*255.0;
                        sfp->normal_map[(offset*3)+1]=((vnorm.y+1.0)/2.0)*255.0;
                        sfp->normal_map[(offset*3)+2]=((vnorm.z+1.0)/2.0)*255.0;
                        vnorm+=delta_vnorm;
                }

                // Update our interpolants
                left_x += delta_left_x;
                right_x += delta_right_x;
                right_vnorm+=delta_right_vnorm;
                left_vnorm+=delta_left_vnorm;
        }
}*/

// Frees memory for specular lighting
void CleanupSpecularLighting(int external) {
  int i, t;

  for (i = 0; i < MAX_ROOMS; i++) {
    if (Rooms[i].used) {
      if (Rooms[i].flags & RF_NO_LIGHT)
        continue;

      if ((Rooms[i].flags & RF_EXTERNAL) && !external)
        continue;

      if (!(Rooms[i].flags & RF_EXTERNAL) && external)
        continue;

      room *rp = &Rooms[i];

      for (t = 0; t < 4; t++) {
        mem_free(Room_strongest_value[i][t]);
      }

      for (t = 0; t < rp->num_faces; t++) {
        face *fp = &rp->faces[t];
        if (GameTextures[fp->tmap].flags & TF_SPECULAR) {
          ASSERT(fp->special_handle != BAD_SPECIAL_FACE_INDEX);
          int j, k, l;

          if (SpecialFaces[fp->special_handle].spec_instance[0].bright_color == 0) {
            // This face didn't get enough light, either free it up or
            // find another face that shares a lightmap and just use that
            // faces values

            int found = 0;
            float strongest_light = 0;
            face *best_face;

            for (l = 0; l < fp->num_verts; l++) {
              int vert_to_check = fp->face_verts[l];
              for (j = 0; j < rp->num_faces; j++) {
                face *this_fp = &rp->faces[j];

                if (this_fp == fp)
                  continue; // don't do self
                if (this_fp->lmi_handle != fp->lmi_handle)
                  continue; // only do faces that have same lightmaps

                if (this_fp->special_handle == BAD_SPECIAL_FACE_INDEX)
                  continue; // Only do specmaps

                if (SpecialFaces[this_fp->special_handle].spec_instance[0].bright_color == 0)
                  continue; // Don't do dark ones

                if (GameTextures[fp->tmap].flags & TF_SMOOTH_SPECULAR)
                  continue; // Don't do smooth shades

                for (k = 0; k < this_fp->num_verts; k++) {
                  if (vert_to_check == this_fp->face_verts[k]) {
                    // We have a match, so see if this face is brighter
                    // than all the others
                    int color = SpecialFaces[this_fp->special_handle].spec_instance[0].bright_color;
                    int r = (color >> 10) & 0x1f;
                    int g = (color >> 5) & 0x1f;
                    int b = (color & 0x1f);
                    float sr = (float)r / 31.0;
                    float sg = (float)g / 31.0;
                    float sb = (float)b / 31.0;

                    float mono_color = (sr * .3) + (sg * .59) + (sb * .11);
                    if (mono_color > strongest_light) {
                      strongest_light = mono_color;
                      found = 1;
                      best_face = this_fp;
                    }
                  }
                }
              }
            }
            // If after all that searching we couldn't find a good light, free it!
            if (!found) {
              FreeSpecialFace(fp->special_handle);
              fp->special_handle = BAD_SPECIAL_FACE_INDEX;
            } else {
              for (int z = 0; z < 4; z++)
                SpecialFaces[fp->special_handle].spec_instance[z] =
                    SpecialFaces[best_face->special_handle].spec_instance[z];
            }
          }
        }
      }
    }
  }
}

// Sets up memory usage for specular lighting
void SetupSpecularLighting(int external) {
  int i, t;
  ClearAllRoomSpecmaps(external);

  for (i = 0; i < MAX_ROOMS; i++) {
    if (Rooms[i].used) {
      if (Rooms[i].flags & RF_NO_LIGHT)
        continue;

      if ((Rooms[i].flags & RF_EXTERNAL) && !external)
        continue;

      if (!(Rooms[i].flags & RF_EXTERNAL) && external)
        continue;

      room *rp = &Rooms[i];

      // Calculate vertex normals for this room
      vector *vertnorms = mem_rmalloc<vector>(rp->num_verts);
      ASSERT(vertnorms);
      for (t = 0; t < rp->num_verts; t++) {
        int total = 0;
        vector normal;
        vm_MakeZero(&normal);

        for (int k = 0; k < rp->num_faces; k++) {
          face *fp = &rp->faces[k];
          for (int j = 0; j < fp->num_verts; j++) {
            if (fp->face_verts[j] == t) {
              total++;
              normal += fp->normal;
            }
          }
        }

        if (total != 0)
          normal /= total;

        vertnorms[t] = normal;
      }

      for (t = 0; t < 4; t++) {
        Room_strongest_value[i][t] = mem_rmalloc<float>(rp->num_faces);
        ASSERT(Room_strongest_value[i][t]);
        memset(Room_strongest_value[i][t], 0, sizeof(float) * rp->num_faces);
      }

      for (t = 0; t < rp->num_faces; t++) {
        face *fp = &rp->faces[t];
        if (GameTextures[fp->tmap].flags & TF_SPECULAR) {
          ASSERT(fp->special_handle == BAD_SPECIAL_FACE_INDEX);

          int n;
          if (GameTextures[fp->tmap].flags & TF_SMOOTH_SPECULAR)
            n = AllocSpecialFace(SFT_SPECULAR, 4, true, fp->num_verts);
          else
            n = AllocSpecialFace(SFT_SPECULAR, 4);

          fp->special_handle = n;

          for (int k = 0; k < 4; k++) {
            SpecialFaces[n].spec_instance[k].bright_color = 0;
            vm_MakeZero(&SpecialFaces[n].spec_instance[k].bright_center);
          }

          // Get vertex normals for this punk
          if (GameTextures[fp->tmap].flags & TF_SMOOTH_SPECULAR) {
            for (int k = 0; k < fp->num_verts; k++) {
              SpecialFaces[n].vertnorms[k] = vertnorms[fp->face_verts[k]];
            }
          }
        }
      }
      mem_free(vertnorms);
    }
  }
}

// Computes the the mines UVs
// Faces can now share one lightmap, so this routine goes through and tries to
// combine as many faces as it can into one lightmap
// Only works on one room
/*void ComputeSingleRoomLightmapUVs (int roomnum)
{
        int t,k;
        int not_combined=0;

        RoomsAlreadyCombined[roomnum]=(uint8_t *)mem_malloc (Rooms[roomnum].num_faces);
        ASSERT (RoomsAlreadyCombined[roomnum]);
        for (k=0;k<Rooms[roomnum].num_faces;k++)
                RoomsAlreadyCombined[roomnum][k]=0;


        for (t=0;t<Rooms[roomnum].num_faces;t++)
        {
                if (*(RoomsAlreadyCombined[roomnum]+t)==0)
                        TestLightAdjacency (roomnum,t,0);
        }

        for (t=0;t<Rooms[roomnum].num_faces;t++)
        {
                if (!RoomsAlreadyCombined[roomnum][t])
                {
                        vector verts[MAX_VERTS_PER_FACE];
                        int room_list[2],face_list[2];
                        for (k=0;k<Rooms[roomnum].faces[t].num_verts;k++)
                                verts[k]=Rooms[roomnum].verts[Rooms[roomnum].faces[t].face_verts[k]];

                        room_list[0]=i;
                        face_list[0]=t;

                        BuildLightmapUVs (room_list,face_list,1,verts,Rooms[roomnum].faces[t].num_verts,external);
                        not_combined++;
                }
        }

        mprintf(0,"%d faces couldn't be combined!\n",not_combined);

        // Free memory
        free (RoomsAlreadyCombined[roomnum]);
}*/