room101/FACE.CPP

#include "face.hpp"
#include "file.hpp"
/*******************************************************************************
** FaceDelete
*******************************************************************************/
void
FaceDelete(Face* face)
{
   assert(face != NULL);
   
   MemoryFree(face->vertices);
   MemoryFree(face->hull);   
}
/*******************************************************************************
** FaceDistanceTo
*******************************************************************************/
float
FaceDistanceTo(Face* face, Vector point, Vector contact_point)
{
   Vector A;
   int   count, i, j;

   assert(face && face->hull);
         
   float dist_to_face = PlaneDistanceTo(face->plane, point);  

   A[0] = point[0] - face->plane[0] * dist_to_face;
   A[1] = point[1] - face->plane[1] * dist_to_face;
   A[2] = point[2] - face->plane[2] * dist_to_face;   
      
   for (count = i = 0; i < NumberOf(face->hull); i++)
   {
      float dist_to_hull = PlaneDistanceTo(face->hull[i], A);

      if (dist_to_hull > 0.0f)
      {
         count++;
         
         contact_point[0] = A[0] - face->hull[i][0] * dist_to_hull;
         contact_point[1] = A[1] - face->hull[i][1] * dist_to_hull;
         contact_point[2] = A[2] - face->hull[i][2] * dist_to_hull;
                              
         for (j = 0; j < NumberOf(face->hull); j++)
         {
            if (j != i && PlaneDistanceTo(face->hull[j], contact_point) > 0.0f) break;
         }         
         if (j == NumberOf(face->hull))
         {
            return (float)sqrt(dist_to_face * dist_to_face + dist_to_hull * dist_to_hull);         
         }         
      } 
   }  
   if (count == 0)
   {
      v3dcpy(contact_point, A);
      
      return dist_to_face < 0.0f ? -dist_to_face : dist_to_face;
   }
   for (i = 0; i < NumberOf(face->vertices); i++)
   {
      VectorSubtract(A, point, face->vertices[i]);    
      
      float distance = VectorMagnitude(A);
      
      if (i == 0 || distance < dist_to_face)
      {
         v3dcpy(contact_point, face->vertices[i]);
         dist_to_face = distance;
      }
   }   
   return dist_to_face;
}
/*******************************************************************************
** FaceRead
*******************************************************************************/
void
FaceRead(Face* face, FILE* file)
{
   memset(face, 0, sizeof(Face));   

   face->vertices  = (Vector*)MemoryRead(file);
   face->hull      = (Plane*) MemoryRead(file);
      
   fread(face->plane     , sizeof(Plane), 1, file);
   fread(&face->colour   , sizeof(int), 1, file);      
   fread(&face->surfaceid, sizeof(int), 1, file);             
}
/*******************************************************************************
** FaceWrite
*******************************************************************************/
void
FaceWrite(Face* face, FILE* file)
{
   assert(face && file);   

   MemoryWrite(face->vertices, file);
   MemoryWrite(face->hull, file);
      
   fwrite(face->plane     , sizeof(Plane), 1, file);
   fwrite(&face->colour   , sizeof(int), 1, file);   
   fwrite(&face->surfaceid, sizeof(int), 1, file);    
}
/*******************************************************************************
** FaceArrayRead
*******************************************************************************/
Face*
FaceArrayRead(FILE* file)
{
   Face* array = (Face*)MemoryAlloc(IntRead(file), sizeof(Face));

   for (int i = 0; i < NumberOf(array); i++)
   {
      FaceRead(&array[i], file);
   }
   return array;
}