Main Page   Namespace List   Class Hierarchy   Compound List   File List   Compound Members   File Members  

polygon.cpp File Reference

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

Go to the source code of this file.

Functions

int SplitPolygon (POLYGON triangleToSplit, POLYGON planeTriangle, POLYGON *triangles)


Function Documentation

int SplitPolygon POLYGON    triangleToSplit,
POLYGON    planeTriangle,
POLYGON   triangles
 

Definition at line 337 of file polygon.cpp.

References Back, ClassifyPoint(), CrossVector(), Front, GetEdgeIntersection(), POLYGON::numVertices, OneFrontOneBack, OneFrontTwoBack, POLYGON::SetNormal(), TwoFrontOneBack, VERTEX::u, VERTEX::v, POLYGON::Vertex, VECTOR::x, VERTEX::x, VECTOR::y, VERTEX::y, VECTOR::z, and VERTEX::z.

Referenced by BuildBSP(), and SelectPartitionfromList().

00338 {
00339     VECTOR planeNormal, polysNormal, pointOnPlane, edge1, edge2, temp;
00340     VERTEX ptA, ptB, outpts[4], inpts[4], intersection;
00341     int count = 0, out_c = 0, in_c = 0, sideA, sideB, outputFlag;
00342     VERTEX texvert1, texvert2; // texture calculation variables
00343     VECTOR t1, t2;
00344     float scale;
00345 
00346     // get a point on the plane
00347     pointOnPlane.x = planeTriangle.Vertex[0].x;
00348     pointOnPlane.y = planeTriangle.Vertex[0].y;
00349     pointOnPlane.z = planeTriangle.Vertex[0].z;
00350 
00351     // get the splitting planes normal
00352     edge1.x = planeTriangle.Vertex[1].x - planeTriangle.Vertex[0].x;
00353     edge1.y = planeTriangle.Vertex[1].y - planeTriangle.Vertex[0].y;
00354     edge1.z = planeTriangle.Vertex[1].z - planeTriangle.Vertex[0].z;
00355     edge2.x = planeTriangle.Vertex[2].x - planeTriangle.Vertex[0].x;
00356     edge2.y = planeTriangle.Vertex[2].y - planeTriangle.Vertex[0].y;
00357     edge2.z = planeTriangle.Vertex[2].z - planeTriangle.Vertex[0].z;
00358     planeNormal = CrossVector(edge1, edge2);
00359 
00360     // get the normal of the triangle to split
00361     edge1.x = triangleToSplit.Vertex[1].x - triangleToSplit.Vertex[0].x;
00362     edge1.y = triangleToSplit.Vertex[1].y - triangleToSplit.Vertex[0].y;
00363     edge1.z = triangleToSplit.Vertex[1].z - triangleToSplit.Vertex[0].z;
00364     edge2.x = triangleToSplit.Vertex[2].x - triangleToSplit.Vertex[0].x;
00365     edge2.y = triangleToSplit.Vertex[2].y - triangleToSplit.Vertex[0].y;
00366     edge2.z = triangleToSplit.Vertex[2].z - triangleToSplit.Vertex[0].z;
00367     polysNormal = CrossVector(edge1, edge2);
00368 
00369     // check if the triangle lies on the plane
00370     for (int loop = 0; loop < 3; loop++)
00371     {
00372         temp.x = triangleToSplit.Vertex[loop].x;
00373         temp.y = triangleToSplit.Vertex[loop].y;
00374         temp.z = triangleToSplit.Vertex[loop].z;
00375         if (ClassifyPoint(temp, pointOnPlane, planeNormal) == 0)
00376             count++;
00377         else
00378             break;
00379     }
00380     if (count == 3)
00381     {
00382         if (ClassifyPoint(polysNormal, pointOnPlane, planeNormal) == 1)
00383             return Front;
00384         if (ClassifyPoint(polysNormal, pointOnPlane, planeNormal) == -1)
00385             return Back;
00386     }
00387 
00388     // find if all of the points are infront of or behind the plane
00389     int frontcount = 0, backcount = 0;
00390     for (int loop = 0; loop < 3; loop++)
00391     {
00392         temp.x = triangleToSplit.Vertex[loop].x;
00393         temp.y = triangleToSplit.Vertex[loop].y;
00394         temp.z = triangleToSplit.Vertex[loop].z;
00395         if (ClassifyPoint(temp, pointOnPlane, planeNormal) == 0)
00396         {
00397             frontcount++;
00398             backcount++;
00399         }
00400         else if (ClassifyPoint(temp, pointOnPlane, planeNormal) == 1)
00401             frontcount++;
00402         else if (ClassifyPoint(temp, pointOnPlane, planeNormal) == -1)
00403             backcount++;
00404     }
00405     if (frontcount == 3)
00406             return Front;
00407     if (backcount == 3)
00408             return Back;
00409 
00410     // try to split the triangle
00411     ptA = triangleToSplit.Vertex[2];
00412     temp.x = ptA.x;
00413     temp.y = ptA.y;
00414     temp.z = ptA.z;
00415     sideA = ClassifyPoint(temp, pointOnPlane, planeNormal);
00416     for (int i = -1; ++i < 3;)
00417     {
00418         ptB = triangleToSplit.Vertex[i];
00419         temp.x = ptB.x;
00420         temp.y = ptB.y;
00421         temp.z = ptB.z;
00422         sideB = ClassifyPoint(temp, pointOnPlane, planeNormal);
00423         if (sideB > 0)
00424         {
00425             if (sideA < 0)
00426             {
00427                 // find intersection
00428                 edge1.x = ptA.x;
00429                 edge1.y = ptA.y;
00430                 edge1.z = ptA.z;
00431                 edge2.x = ptB.x;
00432                 edge2.y = ptB.y;
00433                 edge2.z = ptB.z;
00434 
00435                 temp = GetEdgeIntersection(edge1, edge2, planeTriangle);
00436                 intersection.x = temp.x;
00437                 intersection.y = temp.y;
00438                 intersection.z = temp.z;
00439 
00440                 // find the new texture coordinates
00441                 texvert1.x = ptB.x - ptA.x;
00442                 texvert1.y = ptB.y - ptA.y;
00443                 texvert1.z = ptB.z - ptA.z;
00444                 texvert2.x = intersection.x - ptA.x;
00445                 texvert2.y = intersection.y - ptA.y;
00446                 texvert2.z = intersection.z - ptA.z;
00447                 texvert1.u = ptA.u;
00448                 texvert2.u = ptB.u;
00449                 texvert1.v = ptA.v;
00450                 texvert2.v = ptB.v;
00451                 t1.x = texvert1.x;
00452                 t1.y = texvert1.y;
00453                 t1.z = texvert1.z;
00454                 t2.x = texvert2.x;
00455                 t2.y = texvert2.y;
00456                 t2.z = texvert2.z;
00457                 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);
00458                 intersection.u = texvert1.u + (texvert2.u - texvert1.u) * scale;
00459                 intersection.v = texvert1.v + (texvert2.v - texvert1.v) * scale;
00460 
00461                 outpts[out_c++] = inpts[in_c++] = intersection;
00462             }
00463             inpts[in_c++] = ptB;
00464         }
00465         else if (sideB < 0)
00466         {
00467             if (sideA > 0)
00468             {
00469                 // find intersection
00470                 edge1.x = ptA.x;
00471                 edge1.y = ptA.y;
00472                 edge1.z = ptA.z;
00473                 edge2.x = ptB.x;
00474                 edge2.y = ptB.y;
00475                 edge2.z = ptB.z;
00476 
00477                 temp = GetEdgeIntersection(edge1, edge2, planeTriangle);
00478                 intersection.x = temp.x;
00479                 intersection.y = temp.y;
00480                 intersection.z = temp.z;
00481 
00482                 // find the new texture coordinates
00483                 texvert1.x = ptB.x - ptA.x;
00484                 texvert1.y = ptB.y - ptA.y;
00485                 texvert1.z = ptB.z - ptA.z;
00486                 texvert2.x = intersection.x - ptA.x;
00487                 texvert2.y = intersection.y - ptA.y;
00488                 texvert2.z = intersection.z - ptA.z;
00489                 texvert1.u = ptA.u;
00490                 texvert2.u = ptB.u;
00491                 texvert1.v = ptA.v;
00492                 texvert2.v = ptB.v;
00493                 t1.x = texvert1.x;
00494                 t1.y = texvert1.y;
00495                 t1.z = texvert1.z;
00496                 t2.x = texvert2.x;
00497                 t2.y = texvert2.y;
00498                 t2.z = texvert2.z;
00499                 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);
00500                 intersection.u = texvert1.u + (texvert2.u - texvert1.u) * scale;
00501                 intersection.v = texvert1.v + (texvert2.v - texvert1.v) * scale;
00502 
00503                 outpts[out_c++] = inpts[in_c++] = intersection;
00504             }
00505             outpts[out_c++] = ptB;
00506         }
00507         else
00508             outpts[out_c++] = inpts[in_c++] = ptB;
00509             ptA = ptB;
00510             sideA = sideB;
00511     }
00512 
00513     if (in_c == 4)          // two triangles are infront, one behind
00514     {
00515         outputFlag = TwoFrontOneBack;
00516         if (triangles)
00517         {
00518             triangles[0].Vertex[0] = inpts[0];
00519             triangles[0].Vertex[1] = inpts[1];
00520             triangles[0].Vertex[2] = inpts[2];
00521             triangles[0].numVertices = 3;
00522             triangles[0].SetNormal();
00523             triangles[1].Vertex[0] = inpts[0];
00524             triangles[1].Vertex[1] = inpts[2];
00525             triangles[1].Vertex[2] = inpts[3];
00526             triangles[1].numVertices = 3;
00527             triangles[1].SetNormal();
00528             triangles[2].Vertex[0] = outpts[0];
00529             triangles[2].Vertex[1] = outpts[1];
00530             triangles[2].Vertex[2] = outpts[2];
00531             triangles[2].numVertices = 3;
00532             triangles[2].SetNormal();
00533         }
00534     }
00535     else if (out_c == 4)    // one triangle is infront, two behind
00536     {
00537         outputFlag = OneFrontTwoBack;
00538         if (triangles)
00539         {
00540             triangles[0].Vertex[0] = inpts[0];
00541             triangles[0].Vertex[1] = inpts[1];
00542             triangles[0].Vertex[2] = inpts[2];
00543             triangles[0].numVertices = 3;
00544             triangles[0].SetNormal();
00545             triangles[1].Vertex[0] = outpts[0];
00546             triangles[1].Vertex[1] = outpts[1];
00547             triangles[1].Vertex[2] = outpts[2];
00548             triangles[1].numVertices = 3;
00549             triangles[1].SetNormal();
00550             triangles[2].Vertex[0] = outpts[0];
00551             triangles[2].Vertex[1] = outpts[2];
00552             triangles[2].Vertex[2] = outpts[3];
00553             triangles[2].numVertices = 3;
00554             triangles[2].SetNormal();
00555         }
00556     }
00557     else if (in_c == 3 && out_c == 3)  // plane bisects the triangle
00558     {
00559         outputFlag = OneFrontOneBack;
00560         if (triangles)
00561         {
00562             triangles[0].Vertex[0] = inpts[0];
00563             triangles[0].Vertex[1] = inpts[1];
00564             triangles[0].Vertex[2] = inpts[2];
00565             triangles[0].numVertices = 3;
00566             triangles[0].SetNormal();
00567             triangles[1].Vertex[0] = outpts[0];
00568             triangles[1].Vertex[1] = outpts[1];
00569             triangles[1].Vertex[2] = outpts[2];
00570             triangles[1].numVertices = 3;
00571             triangles[1].SetNormal();
00572         }
00573     }
00574     else // then triangle must be totally infront of or behind the plane
00575     {
00576         int side;
00577 
00578         for (int loop = 0; loop < 3; loop++)
00579         {
00580             temp.x = triangleToSplit.Vertex[loop].x;
00581             temp.y = triangleToSplit.Vertex[loop].y;
00582             temp.z = triangleToSplit.Vertex[loop].z;
00583             side = ClassifyPoint(temp, pointOnPlane, planeNormal);
00584             if (side == 1)
00585             {
00586                 outputFlag = Front;
00587                 break;
00588             }
00589             else if (side == -1)
00590             {
00591                 outputFlag = Back;
00592                 break;
00593             }
00594         }
00595     }
00596     return outputFlag;
00597 }


Generated on Fri Dec 23 05:20:20 2005 for Portals by doxygen1.2.15