---

polygon.cpp

Go to the documentation of this file.

#include <windows.h>
#include "polygon.h"
#include "locmath.h"
#include "collision.h"
#include "general.h"
#include "bsp.h"
#include "mmgr.h"


POLYGON::POLYGON()
:
numVertices(3)
{
    
}

POLYGON::~POLYGON()
{
}

VECTOR POLYGON::GetNormal()
{
        VECTOR temp; 
        float ux;
        float uy;
        float uz;
        float vx;
        float vy;
        float vz;
          ux = Vertex[1].x - Vertex[0].x;
          uy = Vertex[1].y - Vertex[0].y;
          uz = Vertex[1].z - Vertex[0].z;
          vx = Vertex[2].x - Vertex[0].x;
          vy = Vertex[2].y - Vertex[0].y;
          vz = Vertex[2].z - Vertex[0].z;
          temp.x = (uy*vz)-(vy*uz);
          temp.y = (uz*vx)-(vz*ux);
          temp.z = (ux*vy)-(vx*uy);
        return temp;
}

void POLYGON::SetNormal()
{
        float ux;
        float uy;
        float uz;
        float vx;
        float vy;
        float vz;
          ux = Vertex[1].x - Vertex[0].x;
          uy = Vertex[1].y - Vertex[0].y;
          uz = Vertex[1].z - Vertex[0].z;
          vx = Vertex[2].x - Vertex[0].x;
          vy = Vertex[2].y - Vertex[0].y;
          vz = Vertex[2].z - Vertex[0].z;
          Vertex[0].nx = (uy*vz)-(vy*uz);
          Vertex[0].ny = (uz*vx)-(vz*ux);
          Vertex[0].nz = (ux*vy)-(vx*uy);
        Vertex[1].nx = Vertex[0].nx;
          Vertex[1].ny = Vertex[0].ny;
          Vertex[1].nz = Vertex[0].nz;
          Vertex[2].nx = Vertex[0].nx;
          Vertex[2].ny = Vertex[0].ny;
          Vertex[2].nz = Vertex[0].nz;
}

VECTOR GetEdgeIntersection(VECTOR point0, VECTOR point1, POLYGON planePolygon)
{
    VECTOR edge1, edge2, planeNormal, pointOnPlane, intersection, temp;
    float numerator, denominator, t;

    // get a point on the plane
    pointOnPlane.x = planePolygon.Vertex[0].x;
    pointOnPlane.y = planePolygon.Vertex[0].y;
    pointOnPlane.z = planePolygon.Vertex[0].z;

    // get the splitting planes normal
    edge1.x = planePolygon.Vertex[1].x - planePolygon.Vertex[0].x;
    edge1.y = planePolygon.Vertex[1].y - planePolygon.Vertex[0].y;
    edge1.z = planePolygon.Vertex[1].z - planePolygon.Vertex[0].z;
    edge2.x = planePolygon.Vertex[2].x - planePolygon.Vertex[0].x;
    edge2.y = planePolygon.Vertex[2].y - planePolygon.Vertex[0].y;
    edge2.z = planePolygon.Vertex[2].z - planePolygon.Vertex[0].z;
    planeNormal = CrossVector(edge1, edge2);

// find edge intersection:
// intersection = p0 + (p1 - p0) * t
// where t = (planeNormal . (pointOnPlane - p0)) / (planeNormal . (p1 - p0))

    //planeNormal . (pointOnPlane - point0)
    temp.x = pointOnPlane.x - point0.x;
    temp.y = pointOnPlane.y - point0.y;
    temp.z = pointOnPlane.z - point0.z;
    numerator = DotProduct(planeNormal, temp);

    //planeNormal . (point1 - point0)
    temp.x = point1.x - point0.x;
    temp.y = point1.y - point0.y;
    temp.z = point1.z - point0.z;
    denominator = DotProduct(planeNormal, temp);

    if (denominator)
        t = numerator / denominator;
    else
        t = 0.0;

    intersection.x = point0.x + temp.x * t;
    intersection.y = point0.y + temp.y * t;
    intersection.z = point0.z + temp.z * t;

    return intersection;
}

/*
 Although this function is called SplitPolygon, it really only splits triangles, the
 function inputs the triangle to be split and another triangle to be used for the splitting
 plane. The parameter 'polygons' is a pointer to 3 triangles for output.
 The function splits the input triangle into either 0, 2 or 3 new triangles with
 recalculated texture coordinates.
 If the polygons pointer happens to be NULL then the function will just set the outputFlag and return.

 The return value will be either Front, Back, TwoFrontOneBack, OneFrontTwoBack or OneFrontOneBack.
 Front means that all points are infront of the plane or the polygon lies on the plane and faces the front.
 Back means that all points are behind of the plane or the polygon lies on the plane and faces the back.
 TwoFrontOneBack means that polygons 1 and 2 are infront of the plane and polygon 3 is behind.
 OneFrontTwoBack means that polygon 1 is infront of the plane and polygons 2 and 3 are behind.
 OneFrontOneBack means that polygon 1 is infront of the plane and polygon 2 is behind, polygon 3 is not used.
*/
/*
int SplitPolygon(POLYGON polygonToSplit, POLYGON planePolygon, POLYGON* polygons)
{
    VECTOR planeNormal, polysNormal, pointOnPlane, edge1, edge2, temp;
    VERTEX ptA, ptB, outpts[4], inpts[4], intersection;
    int count = 0, out_c = 0, in_c = 0, sideA, sideB, outputFlag;
    float x1, x2, y1, y2, z1, z2, u1, u2, v1, v2, scale; // texture calculation variables

    // get a point on the plane
    pointOnPlane.x = planePolygon.Vertex[0].x;
    pointOnPlane.y = planePolygon.Vertex[0].y;
    pointOnPlane.z = planePolygon.Vertex[0].z;

    // get the splitting planes normal
    edge1.x = planePolygon.Vertex[1].x - planePolygon.Vertex[0].x;
    edge1.y = planePolygon.Vertex[1].y - planePolygon.Vertex[0].y;
    edge1.z = planePolygon.Vertex[1].z - planePolygon.Vertex[0].z;
    edge2.x = planePolygon.Vertex[2].x - planePolygon.Vertex[0].x;
    edge2.y = planePolygon.Vertex[2].y - planePolygon.Vertex[0].y;
    edge2.z = planePolygon.Vertex[2].z - planePolygon.Vertex[0].z;
    planeNormal = CrossVector(edge1, edge2);

    // get the normal of the polygon to split
    edge1.x = polygonToSplit.Vertex[1].x - polygonToSplit.Vertex[0].x;
    edge1.y = polygonToSplit.Vertex[1].y - polygonToSplit.Vertex[0].y;
    edge1.z = polygonToSplit.Vertex[1].z - polygonToSplit.Vertex[0].z;
    edge2.x = polygonToSplit.Vertex[2].x - polygonToSplit.Vertex[0].x;
    edge2.y = polygonToSplit.Vertex[2].y - polygonToSplit.Vertex[0].y;
    edge2.z = polygonToSplit.Vertex[2].z - polygonToSplit.Vertex[0].z;
    polysNormal = CrossVector(edge1, edge2);

    // check if the polygon lies on the plane
    for (int loop = 0; loop < 3; loop++)
    {
        temp.x = polygonToSplit.Vertex[loop].x;
        temp.y = polygonToSplit.Vertex[loop].y;
        temp.z = polygonToSplit.Vertex[loop].z;
        if (ClassifyPoint(temp, pointOnPlane, planeNormal) == 0)
            count++;
        else
            break;
    }
    if (count == 3)
    {
        if (ClassifyPoint(polysNormal, pointOnPlane, planeNormal) == 1)
            return Front;
        if (ClassifyPoint(polysNormal, pointOnPlane, planeNormal) == -1)
            return Back;
    }

    // find if all of the points are infront of or behind the plane
    int frontcount = 0, backcount = 0;
    for (int loop = 0; loop < 3; loop++)
    {
        temp.x = polygonToSplit.Vertex[loop].x;
        temp.y = polygonToSplit.Vertex[loop].y;
        temp.z = polygonToSplit.Vertex[loop].z;
        if (ClassifyPoint(temp, pointOnPlane, planeNormal) == 0)
        {
            frontcount++;
            backcount++;
        }
        else if (ClassifyPoint(temp, pointOnPlane, planeNormal) == 1)
            frontcount++;
        else if (ClassifyPoint(temp, pointOnPlane, planeNormal) == -1)
            backcount++;
    }
    if (frontcount == 3)
            return Front;
    if (backcount == 3)
            return Back;

    // try to split the polygon
    ptA = polygonToSplit.Vertex[2];
    temp.x = ptA.x;
    temp.y = ptA.y;
    temp.z = ptA.z;
    sideA = ClassifyPoint(temp, pointOnPlane, planeNormal);
    for (int i = -1; ++i < 3;)
    {
        ptB = polygonToSplit.Vertex[i];
        temp.x = ptB.x;
        temp.y = ptB.y;
        temp.z = ptB.z;
        sideB = ClassifyPoint(temp, pointOnPlane, planeNormal);
        if (sideB > 0)
        {
            if (sideA < 0)
            {
                // find intersection
                edge1.x = ptA.x;
                edge1.y = ptA.y;
                edge1.z = ptA.z;
                edge2.x = ptB.x;
                edge2.y = ptB.y;
                edge2.z = ptB.z;

                temp = GetEdgeIntersection(edge1, edge2, planePolygon);
                intersection.x = temp.x;
                intersection.y = temp.y;
                intersection.z = temp.z;

                // find the new texture coordinates
                x1 = ptB.x - ptA.x;
                y1 = ptB.y - ptA.y;
                z1 = ptB.z - ptA.z;
                x2 = intersection.x - ptA.x;
                y2 = intersection.y - ptA.y;
                z2 = intersection.z - ptA.z;
                u1 = ptA.u;
                u2 = ptB.u;
                v1 = ptA.v;
                v2 = ptB.v;
                scale = sqrt(x2*x2+y2*y2+z2*z2)/sqrt(x1*x1+y1*y1+z1*z1);
                intersection.u = u1 + (u2-u1) * scale;
                intersection.v = v1 + (v2-v1) * scale;

                outpts[out_c++] = inpts[in_c++] = intersection;
            }
            inpts[in_c++] = ptB;
        }
        else if (sideB < 0)
        {
            if (sideA > 0)
            {
                // find intersection
                edge1.x = ptA.x;
                edge1.y = ptA.y;
                edge1.z = ptA.z;
                edge2.x = ptB.x;
                edge2.y = ptB.y;
                edge2.z = ptB.z;

                temp = GetEdgeIntersection(edge1, edge2, planePolygon);
                intersection.x = temp.x;
                intersection.y = temp.y;
                intersection.z = temp.z;

                // find the new texture coordinates
                x1 = ptB.x - ptA.x;
                y1 = ptB.y - ptA.y;
                z1 = ptB.z - ptA.z;
                x2 = intersection.x - ptA.x;
                y2 = intersection.y - ptA.y;
                z2 = intersection.z - ptA.z;
                u1 = ptA.u;
                u2 = ptB.u;
                v1 = ptA.v;
                v2 = ptB.v;
                scale = sqrt(x2*x2+y2*y2+z2*z2)/sqrt(x1*x1+y1*y1+z1*z1);
                intersection.u = u1 + (u2-u1) * scale;
                intersection.v = v1 + (v2-v1) * scale;

                outpts[out_c++] = inpts[in_c++] = intersection;
            }
            outpts[out_c++] = ptB;
        }
        else
            outpts[out_c++] = inpts[in_c++] = ptB;
            ptA = ptB;
            sideA = sideB;
    }

    if (in_c == 4)          // two polygons are infront, one behind
    {
        outputFlag = TwoFrontOneBack;
        if (polygons)
        {
            polygons[0].Vertex[0] = inpts[0];
            polygons[0].Vertex[1] = inpts[1];
            polygons[0].Vertex[2] = inpts[2];
            polygons[0].SetNormal();
            polygons[1].Vertex[0] = inpts[0];
            polygons[1].Vertex[1] = inpts[2];
            polygons[1].Vertex[2] = inpts[3];
            polygons[1].SetNormal();
            polygons[2].Vertex[0] = outpts[0];
            polygons[2].Vertex[1] = outpts[1];
            polygons[2].Vertex[2] = outpts[2];
            polygons[2].SetNormal();
        }
    }
    else if (out_c == 4)    // one polygon is infront, two behind
    {
        outputFlag = OneFrontTwoBack;
        if (polygons)
        {
            polygons[0].Vertex[0] = inpts[0];
            polygons[0].Vertex[1] = inpts[1];
            polygons[0].Vertex[2] = inpts[2];
            polygons[0].SetNormal();
            polygons[1].Vertex[0] = outpts[0];
            polygons[1].Vertex[1] = outpts[1];
            polygons[1].Vertex[2] = outpts[2];
            polygons[1].SetNormal();
            polygons[2].Vertex[0] = outpts[0];
            polygons[2].Vertex[1] = outpts[2];
            polygons[2].Vertex[2] = outpts[3];
            polygons[2].SetNormal();
        }
    }
    else if (in_c == 3 && out_c == 3)  // plane bisects the polygon
    {
        outputFlag = OneFrontOneBack;
        if (polygons)
        {
            polygons[0].Vertex[0] = inpts[0];
            polygons[0].Vertex[1] = inpts[1];
            polygons[0].Vertex[2] = inpts[2];
            polygons[0].SetNormal();
            polygons[1].Vertex[0] = outpts[0];
            polygons[1].Vertex[1] = outpts[1];
            polygons[1].Vertex[2] = outpts[2];
            polygons[1].SetNormal();
        }
    }
    else // then polygon must be totally infront of or behind the plane
    {
        int side;

        for (int loop = 0; loop < 3; loop++)
        {
            temp.x = polygonToSplit.Vertex[loop].x;
            temp.y = polygonToSplit.Vertex[loop].y;
            temp.z = polygonToSplit.Vertex[loop].z;
            side = ClassifyPoint(temp, pointOnPlane, planeNormal);
            if (side == 1)
            {
                outputFlag = Front;
                break;
            }
            else if (side == -1)
            {
                outputFlag = Back;
                break;
            }
        }
    }
    return outputFlag;
}
*/
/*
 This function only splits triangles, the function inputs the triangle to be 
 split and another triangle to be used for the splitting plane. 
 The parameter 'triangles' is a pointer to 3 triangles for output.
 The function splits the input triangle into either 0, 2 or 3 new triangles with
 recalculated texture coordinates.
 If the triangles pointer happens to be NULL then the function will just set the outputFlag and return.

 The return value will be either Front, Back, TwoFrontOneBack, OneFrontTwoBack or OneFrontOneBack.
 Front means that all points are infront of the plane or the triangle lies on the plane and faces the front.
 Back means that all points are behind of the plane or the triangle lies on the plane and faces the back.
 TwoFrontOneBack means that triangles 1 and 2 are infront of the plane and triangle 3 is behind.
 OneFrontTwoBack means that triangle 1 is infront of the plane and triangles 2 and 3 are behind.
 OneFrontOneBack means that triangle 1 is infront of the plane and triangle 2 is behind, triangle 3 is not used.
*/
int SplitPolygon(POLYGON triangleToSplit, POLYGON planeTriangle, POLYGON* triangles)
{
    VECTOR planeNormal, polysNormal, pointOnPlane, edge1, edge2, temp;
    VERTEX ptA, ptB, outpts[4], inpts[4], intersection;
    int count = 0, out_c = 0, in_c = 0, sideA, sideB, outputFlag;
    VERTEX texvert1, texvert2; // texture calculation variables
    VECTOR t1, t2;
    float scale;

    // get a point on the plane
    pointOnPlane.x = planeTriangle.Vertex[0].x;
    pointOnPlane.y = planeTriangle.Vertex[0].y;
    pointOnPlane.z = planeTriangle.Vertex[0].z;

    // get the splitting planes normal
    edge1.x = planeTriangle.Vertex[1].x - planeTriangle.Vertex[0].x;
    edge1.y = planeTriangle.Vertex[1].y - planeTriangle.Vertex[0].y;
    edge1.z = planeTriangle.Vertex[1].z - planeTriangle.Vertex[0].z;
    edge2.x = planeTriangle.Vertex[2].x - planeTriangle.Vertex[0].x;
    edge2.y = planeTriangle.Vertex[2].y - planeTriangle.Vertex[0].y;
    edge2.z = planeTriangle.Vertex[2].z - planeTriangle.Vertex[0].z;
    planeNormal = CrossVector(edge1, edge2);

    // get the normal of the triangle to split
    edge1.x = triangleToSplit.Vertex[1].x - triangleToSplit.Vertex[0].x;
    edge1.y = triangleToSplit.Vertex[1].y - triangleToSplit.Vertex[0].y;
    edge1.z = triangleToSplit.Vertex[1].z - triangleToSplit.Vertex[0].z;
    edge2.x = triangleToSplit.Vertex[2].x - triangleToSplit.Vertex[0].x;
    edge2.y = triangleToSplit.Vertex[2].y - triangleToSplit.Vertex[0].y;
    edge2.z = triangleToSplit.Vertex[2].z - triangleToSplit.Vertex[0].z;
    polysNormal = CrossVector(edge1, edge2);

    // check if the triangle lies on the plane
    for (int loop = 0; loop < 3; loop++)
    {
        temp.x = triangleToSplit.Vertex[loop].x;
        temp.y = triangleToSplit.Vertex[loop].y;
        temp.z = triangleToSplit.Vertex[loop].z;
        if (ClassifyPoint(temp, pointOnPlane, planeNormal) == 0)
            count++;
        else
            break;
    }
    if (count == 3)
    {
        if (ClassifyPoint(polysNormal, pointOnPlane, planeNormal) == 1)
            return Front;
        if (ClassifyPoint(polysNormal, pointOnPlane, planeNormal) == -1)
            return Back;
    }

    // find if all of the points are infront of or behind the plane
    int frontcount = 0, backcount = 0;
    for (int loop = 0; loop < 3; loop++)
    {
        temp.x = triangleToSplit.Vertex[loop].x;
        temp.y = triangleToSplit.Vertex[loop].y;
        temp.z = triangleToSplit.Vertex[loop].z;
        if (ClassifyPoint(temp, pointOnPlane, planeNormal) == 0)
        {
            frontcount++;
            backcount++;
        }
        else if (ClassifyPoint(temp, pointOnPlane, planeNormal) == 1)
            frontcount++;
        else if (ClassifyPoint(temp, pointOnPlane, planeNormal) == -1)
            backcount++;
    }
    if (frontcount == 3)
            return Front;
    if (backcount == 3)
            return Back;

    // try to split the triangle
    ptA = triangleToSplit.Vertex[2];
    temp.x = ptA.x;
    temp.y = ptA.y;
    temp.z = ptA.z;
    sideA = ClassifyPoint(temp, pointOnPlane, planeNormal);
    for (int i = -1; ++i < 3;)
    {
        ptB = triangleToSplit.Vertex[i];
        temp.x = ptB.x;
        temp.y = ptB.y;
        temp.z = ptB.z;
        sideB = ClassifyPoint(temp, pointOnPlane, planeNormal);
        if (sideB > 0)
        {
            if (sideA < 0)
            {
                // find intersection
                edge1.x = ptA.x;
                edge1.y = ptA.y;
                edge1.z = ptA.z;
                edge2.x = ptB.x;
                edge2.y = ptB.y;
                edge2.z = ptB.z;

                temp = GetEdgeIntersection(edge1, edge2, planeTriangle);
                intersection.x = temp.x;
                intersection.y = temp.y;
                intersection.z = temp.z;

                // find the new texture coordinates
                texvert1.x = ptB.x - ptA.x;
                texvert1.y = ptB.y - ptA.y;
                texvert1.z = ptB.z - ptA.z;
                texvert2.x = intersection.x - ptA.x;
                texvert2.y = intersection.y - ptA.y;
                texvert2.z = intersection.z - ptA.z;
                texvert1.u = ptA.u;
                texvert2.u = ptB.u;
                texvert1.v = ptA.v;
                texvert2.v = ptB.v;
                t1.x = texvert1.x;
                t1.y = texvert1.y;
                t1.z = texvert1.z;
                t2.x = texvert2.x;
                t2.y = texvert2.y;
                t2.z = texvert2.z;
                scale = sqrt(t2.x*t2.x+t2.y*t2.y+t2.z*t2.z)/sqrt(t1.x*t1.x+t1.y*t1.y+t1.z*t1.z);
                intersection.u = texvert1.u + (texvert2.u - texvert1.u) * scale;
                intersection.v = texvert1.v + (texvert2.v - texvert1.v) * scale;

                outpts[out_c++] = inpts[in_c++] = intersection;
            }
            inpts[in_c++] = ptB;
        }
        else if (sideB < 0)
        {
            if (sideA > 0)
            {
                // find intersection
                edge1.x = ptA.x;
                edge1.y = ptA.y;
                edge1.z = ptA.z;
                edge2.x = ptB.x;
                edge2.y = ptB.y;
                edge2.z = ptB.z;

                temp = GetEdgeIntersection(edge1, edge2, planeTriangle);
                intersection.x = temp.x;
                intersection.y = temp.y;
                intersection.z = temp.z;

                // find the new texture coordinates
                texvert1.x = ptB.x - ptA.x;
                texvert1.y = ptB.y - ptA.y;
                texvert1.z = ptB.z - ptA.z;
                texvert2.x = intersection.x - ptA.x;
                texvert2.y = intersection.y - ptA.y;
                texvert2.z = intersection.z - ptA.z;
                texvert1.u = ptA.u;
                texvert2.u = ptB.u;
                texvert1.v = ptA.v;
                texvert2.v = ptB.v;
                t1.x = texvert1.x;
                t1.y = texvert1.y;
                t1.z = texvert1.z;
                t2.x = texvert2.x;
                t2.y = texvert2.y;
                t2.z = texvert2.z;
                scale = sqrt(t2.x*t2.x+t2.y*t2.y+t2.z*t2.z)/sqrt(t1.x*t1.x+t1.y*t1.y+t1.z*t1.z);
                intersection.u = texvert1.u + (texvert2.u - texvert1.u) * scale;
                intersection.v = texvert1.v + (texvert2.v - texvert1.v) * scale;

                outpts[out_c++] = inpts[in_c++] = intersection;
            }
            outpts[out_c++] = ptB;
        }
        else
            outpts[out_c++] = inpts[in_c++] = ptB;
            ptA = ptB;
            sideA = sideB;
    }

    if (in_c == 4)          // two triangles are infront, one behind
    {
        outputFlag = TwoFrontOneBack;
        if (triangles)
        {
            triangles[0].Vertex[0] = inpts[0];
            triangles[0].Vertex[1] = inpts[1];
            triangles[0].Vertex[2] = inpts[2];
            triangles[0].numVertices = 3;
            triangles[0].SetNormal();
            triangles[1].Vertex[0] = inpts[0];
            triangles[1].Vertex[1] = inpts[2];
            triangles[1].Vertex[2] = inpts[3];
            triangles[1].numVertices = 3;
            triangles[1].SetNormal();
            triangles[2].Vertex[0] = outpts[0];
            triangles[2].Vertex[1] = outpts[1];
            triangles[2].Vertex[2] = outpts[2];
            triangles[2].numVertices = 3;
            triangles[2].SetNormal();
        }
    }
    else if (out_c == 4)    // one triangle is infront, two behind
    {
        outputFlag = OneFrontTwoBack;
        if (triangles)
        {
            triangles[0].Vertex[0] = inpts[0];
            triangles[0].Vertex[1] = inpts[1];
            triangles[0].Vertex[2] = inpts[2];
            triangles[0].numVertices = 3;
            triangles[0].SetNormal();
            triangles[1].Vertex[0] = outpts[0];
            triangles[1].Vertex[1] = outpts[1];
            triangles[1].Vertex[2] = outpts[2];
            triangles[1].numVertices = 3;
            triangles[1].SetNormal();
            triangles[2].Vertex[0] = outpts[0];
            triangles[2].Vertex[1] = outpts[2];
            triangles[2].Vertex[2] = outpts[3];
            triangles[2].numVertices = 3;
            triangles[2].SetNormal();
        }
    }
    else if (in_c == 3 && out_c == 3)  // plane bisects the triangle
    {
        outputFlag = OneFrontOneBack;
        if (triangles)
        {
            triangles[0].Vertex[0] = inpts[0];
            triangles[0].Vertex[1] = inpts[1];
            triangles[0].Vertex[2] = inpts[2];
            triangles[0].numVertices = 3;
            triangles[0].SetNormal();
            triangles[1].Vertex[0] = outpts[0];
            triangles[1].Vertex[1] = outpts[1];
            triangles[1].Vertex[2] = outpts[2];
            triangles[1].numVertices = 3;
            triangles[1].SetNormal();
        }
    }
    else // then triangle must be totally infront of or behind the plane
    {
        int side;

        for (int loop = 0; loop < 3; loop++)
        {
            temp.x = triangleToSplit.Vertex[loop].x;
            temp.y = triangleToSplit.Vertex[loop].y;
            temp.z = triangleToSplit.Vertex[loop].z;
            side = ClassifyPoint(temp, pointOnPlane, planeNormal);
            if (side == 1)
            {
                outputFlag = Front;
                break;
            }
            else if (side == -1)
            {
                outputFlag = Back;
                break;
            }
        }
    }
    return outputFlag;
}
/*
int ClassifyPolygon(POLYGON* Polygon, POLYGON planePolygon)
{
    int numVerts = Polygon->numVertices;
    int count = 0;
    VECTOR planeNormal, polysNormal, pointOnPlane, edge1, edge2, temp;

    // get a point on the plane
    pointOnPlane = planePolygon.Vertex[0].coords;

    // get the planes normal
    edge1 = planePolygon.Vertex[1].coords - planePolygon.Vertex[0].coords;
    edge2 = planePolygon.Vertex[2].coords - planePolygon.Vertex[0].coords;
    planeNormal = CrossVector(edge1, edge2);

    // get the normal of the Polygon
    edge1 = Polygon->Vertex[1].coords - Polygon->Vertex[0].coords;
    edge2 = Polygon->Vertex[2].coords - Polygon->Vertex[0].coords;
    polysNormal = CrossVector(edge1, edge2);

    // check if the polygon lies on the plane
    for (int loop = 0; loop < numVerts; loop++)
    {
        temp = Polygon->Vertex[loop].coords;
        if (ClassifyPoint(temp, pointOnPlane, planeNormal) == 0)
            count++;
        else
            break;
    }
    if (count == numVerts)
            return OnPartition;

    // find if all of the points are infront of or behind the plane
    int result, frontcount = 0, backcount = 0;
    for (int loop = 0; loop < numVerts; loop++)
    {
        temp = Polygon->Vertex[loop].coords;
        result = ClassifyPoint(temp, pointOnPlane, planeNormal);
        if (result == 0)
        {
            frontcount++;
            backcount++;
        }
        else
            if (result == 1)
                frontcount++;
        else
            if (result == -1)
                backcount++;
    }
    if (frontcount == numVerts)
            return Front;
    if (backcount == numVerts)
            return Back;

    return PolygonWasSplit;
}

void InvertPolygon(POLYGON* Polygon)
{
    POLYGON temppolygon = *Polygon;
    for (int loop = 0; loop < Polygon->numVertices; loop++)
        Polygon->Vertex[loop] = temppolygon.Vertex[(Polygon->numVertices - 1) - loop];
    Polygon->SetNormal();
    return;
}
*/

---