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

portal.h File Reference

#include "vector.h"
#include "vertex.h"
#include "polygon.h"
#include "plane.h"

Go to the source code of this file.

Compounds

class  PORTAL

Functions

PORTALCopyPortal (PORTAL *portal)
void CreateLargePortal (POLYGON splittingPolygon, PORTAL *largePortal)
int SplitPortal (PORTAL *portalToSplit, PLANE plane, VECTOR pointOnPlane, PORTAL *front, PORTAL *back)
int SplitPortal (PORTAL *portalToSplit, POLYGON planePolygon, PORTAL *front, PORTAL *back)
void MakePortalList ()
int ClassifyPortal (PORTAL *portal, POLYGON planePolygon)
int ClassifyInvertedPortal (PORTAL *portal, POLYGON planePolygon)
void InvertPortal (PORTAL *portal)
void InvertPortals (BSP_node *node)
void AddPortal (PORTAL *thisportal, BSP_node *node)
void AddPortalsToLeaves (BSP_node *root)
int ClipPortalToFrontLeaf (PORTAL *portal)
int ClipPortalToBackLeaf (PORTAL *portal)
void CheckForSinglePortals (BSP_node *node, BSP_node *originalnode, PORTAL *portal, int *flag)
int RemoveExtraPortals (PORTAL *portal)
void FindTruePortals (BSP_node *node)


Function Documentation

void AddPortal PORTAL   thisportal,
BSP_node   node
 

Definition at line 811 of file portal.cpp.

References Back, BSP_node::backnode, ClassifyPortal(), CopyPortal(), Front, BSP_node::frontnode, LinkedList< PORTAL >::Insert(), BSP_node::leaf, PORTAL::linkPosition, BSP_node::numportals, OnPartition, BSP_node::partition, and BSP_node::portallist.

Referenced by AddPortalsToLeaves().

00812 {
00813     if (node->leaf == true)
00814     {
00815         node->numportals++;
00816         thisportal->linkPosition = node->numportals;
00817         node->portallist.Insert(thisportal);
00818         return;
00819     }
00820 
00821     int side = ClassifyPortal(thisportal, node->partition);
00822     if (side == Front)
00823     {
00824         AddPortal(thisportal, node->frontnode);
00825     }
00826     if (side == Back)
00827     {
00828         AddPortal(thisportal, node->backnode);
00829     }
00830     if (side == OnPartition)
00831     {
00832         AddPortal(thisportal, node->frontnode);
00833         PORTAL* tempportal = CopyPortal(thisportal);
00834         AddPortal(tempportal, node->backnode);
00835     }
00836     return;
00837 }

void AddPortalsToLeaves BSP_node   root
 

Definition at line 839 of file portal.cpp.

References AddPortal(), CopyPortal(), LinkedList< T >::Get(), and numportals.

Referenced by InitGL().

00840 {
00841     for (int loop = 1; loop <= numportals; loop++)
00842     {
00843         PORTAL* tempportal = CopyPortal(PortalList.Get(loop));
00844         AddPortal(tempportal, root);
00845     }
00846 }

void CheckForSinglePortals BSP_node   node,
BSP_node   originalnode,
PORTAL   portal,
int *    flag
 

Definition at line 909 of file portal.cpp.

References PORTAL::backleaf, BSP_node::backnode, PORTAL::frontleaf, BSP_node::frontnode, LinkedList< PORTAL >::Get(), BSP_node::leaf, BSP_node::nodeid, BSP_node::numportals, PORTAL::PortalId, and BSP_node::portallist.

Referenced by FindTruePortals().

00910 {
00911     PORTAL* tempportal;
00912     if (node->leaf == true)
00913     {
00914         if (node->nodeid != originalnode->nodeid)
00915         {
00916             for (int portalnum = node->numportals; portalnum > 0; portalnum--)
00917             {
00918                 tempportal = node->portallist.Get(portalnum);
00919                 if (tempportal->PortalId == portal->PortalId)
00920                 {
00921                     portal->frontleaf = originalnode;
00922                     portal->backleaf = node;
00923                     *flag += 1;
00924                 }
00925             }
00926         }
00927         return;
00928     }
00929     else
00930     {
00931         CheckForSinglePortals(node->frontnode, originalnode, portal, flag);
00932         CheckForSinglePortals(node->backnode, originalnode, portal, flag);
00933         return;
00934     }
00935 }

int ClassifyInvertedPortal PORTAL   portal,
POLYGON    planePolygon
 

Definition at line 668 of file portal.cpp.

References Back, ClassifyPoint(), CrossVector(), Front, PORTAL::numVertices, PORTAL::Vertex, POLYGON::Vertex, VERTEX::x, VECTOR::x, VERTEX::y, VECTOR::y, VERTEX::z, and VECTOR::z.

Referenced by RemoveExtraPortals().

00669 {
00670     int numVerts = portal->numVertices;
00671     int count = 0;
00672     VECTOR planeNormal, polysNormal, pointOnPlane, edge1, edge2, temp;
00673 
00674     // get a point on the plane
00675     pointOnPlane.x = planePolygon.Vertex[0].x;
00676     pointOnPlane.y = planePolygon.Vertex[0].y;
00677     pointOnPlane.z = planePolygon.Vertex[0].z;
00678 
00679     // get the planes normal
00680     edge1.x = planePolygon.Vertex[1].x - planePolygon.Vertex[0].x;
00681     edge1.y = planePolygon.Vertex[1].y - planePolygon.Vertex[0].y;
00682     edge1.z = planePolygon.Vertex[1].z - planePolygon.Vertex[0].z;
00683     edge2.x = planePolygon.Vertex[2].x - planePolygon.Vertex[0].x;
00684     edge2.y = planePolygon.Vertex[2].y - planePolygon.Vertex[0].y;
00685     edge2.z = planePolygon.Vertex[2].z - planePolygon.Vertex[0].z;
00686     planeNormal = CrossVector(edge1, edge2);
00687 
00688     // get the normal of the portal
00689     edge1.x = portal->Vertex[1].x - portal->Vertex[0].x;
00690     edge1.y = portal->Vertex[1].y - portal->Vertex[0].y;
00691     edge1.z = portal->Vertex[1].z - portal->Vertex[0].z;
00692     edge2.x = portal->Vertex[2].x - portal->Vertex[0].x;
00693     edge2.y = portal->Vertex[2].y - portal->Vertex[0].y;
00694     edge2.z = portal->Vertex[2].z - portal->Vertex[0].z;
00695     polysNormal = CrossVector(edge1, edge2);
00696     polysNormal.x *= -1;
00697     polysNormal.y *= -1;
00698     polysNormal.z *= -1;
00699 
00700     // check if the portal lies on the plane
00701     for (int loop = 0; loop < numVerts; loop++)
00702     {
00703         temp.x = portal->Vertex[loop].x;
00704         temp.y = portal->Vertex[loop].y;
00705         temp.z = portal->Vertex[loop].z;
00706         if (ClassifyPoint(temp, pointOnPlane, planeNormal) == 0)
00707             count++;
00708         else
00709             break;
00710     }
00711     if (count == numVerts)
00712     {
00713         if (ClassifyPoint(polysNormal, pointOnPlane, planeNormal) == 1)
00714             return Front;
00715         if (ClassifyPoint(polysNormal, pointOnPlane, planeNormal) == -1)
00716             return Back;
00717     }
00718 
00719     // find if all of the points are infront of or behind the plane
00720     int result, frontcount = 0, backcount = 0;
00721     for (int loop = 0; loop < numVerts; loop++)
00722     {
00723         temp.x = portal->Vertex[loop].x;
00724         temp.y = portal->Vertex[loop].y;
00725         temp.z = portal->Vertex[loop].z;
00726         result = ClassifyPoint(temp, pointOnPlane, planeNormal);
00727         if (result == 0)
00728         {
00729             frontcount++;
00730             backcount++;
00731         }
00732         else
00733             if (result == 1)
00734                 frontcount++;
00735         else
00736             if (result == -1)
00737                 backcount++;
00738     }
00739     if (frontcount == numVerts)
00740             return Front;
00741     if (backcount == numVerts)
00742             return Back;
00743 
00744     return 0;
00745 }

int ClassifyPortal PORTAL   portal,
POLYGON    planePolygon
 

Definition at line 597 of file portal.cpp.

References Back, ClassifyPoint(), CrossVector(), Front, PORTAL::numVertices, OnPartition, PORTAL::Vertex, POLYGON::Vertex, VERTEX::x, VECTOR::x, VERTEX::y, VECTOR::y, VERTEX::z, and VECTOR::z.

Referenced by AddPortal().

00598 {
00599     int numVerts = portal->numVertices;
00600     int count = 0;
00601     VECTOR planeNormal, polysNormal, pointOnPlane, edge1, edge2, temp;
00602 
00603     // get a point on the plane
00604     pointOnPlane.x = planePolygon.Vertex[0].x;
00605     pointOnPlane.y = planePolygon.Vertex[0].y;
00606     pointOnPlane.z = planePolygon.Vertex[0].z;
00607 
00608     // get the planes normal
00609     edge1.x = planePolygon.Vertex[1].x - planePolygon.Vertex[0].x;
00610     edge1.y = planePolygon.Vertex[1].y - planePolygon.Vertex[0].y;
00611     edge1.z = planePolygon.Vertex[1].z - planePolygon.Vertex[0].z;
00612     edge2.x = planePolygon.Vertex[2].x - planePolygon.Vertex[0].x;
00613     edge2.y = planePolygon.Vertex[2].y - planePolygon.Vertex[0].y;
00614     edge2.z = planePolygon.Vertex[2].z - planePolygon.Vertex[0].z;
00615     planeNormal = CrossVector(edge1, edge2);
00616 
00617     // get the normal of the portal
00618     edge1.x = portal->Vertex[1].x - portal->Vertex[0].x;
00619     edge1.y = portal->Vertex[1].y - portal->Vertex[0].y;
00620     edge1.z = portal->Vertex[1].z - portal->Vertex[0].z;
00621     edge2.x = portal->Vertex[2].x - portal->Vertex[0].x;
00622     edge2.y = portal->Vertex[2].y - portal->Vertex[0].y;
00623     edge2.z = portal->Vertex[2].z - portal->Vertex[0].z;
00624     polysNormal = CrossVector(edge1, edge2);
00625 
00626     // check if the portal lies on the plane
00627     for (int loop = 0; loop < numVerts; loop++)
00628     {
00629         temp.x = portal->Vertex[loop].x;
00630         temp.y = portal->Vertex[loop].y;
00631         temp.z = portal->Vertex[loop].z;
00632         if (ClassifyPoint(temp, pointOnPlane, planeNormal) == 0)
00633             count++;
00634         else
00635             break;
00636     }
00637     if (count == numVerts)
00638             return OnPartition;
00639 
00640     // find if all of the points are infront of or behind the plane
00641     int result, frontcount = 0, backcount = 0;
00642     for (int loop = 0; loop < numVerts; loop++)
00643     {
00644         temp.x = portal->Vertex[loop].x;
00645         temp.y = portal->Vertex[loop].y;
00646         temp.z = portal->Vertex[loop].z;
00647         result = ClassifyPoint(temp, pointOnPlane, planeNormal);
00648         if (result == 0)
00649         {
00650             frontcount++;
00651             backcount++;
00652         }
00653         else
00654             if (result == 1)
00655                 frontcount++;
00656         else
00657             if (result == -1)
00658                 backcount++;
00659     }
00660     if (frontcount == numVerts)
00661             return Front;
00662     if (backcount == numVerts)
00663             return Back;
00664 
00665     return 0;
00666 }

int ClipPortalToBackLeaf PORTAL   portal
 

Definition at line 879 of file portal.cpp.

References PORTAL::backleaf, BSP_node::nodepolylist, BSP_node::numpolys, PORTAL::numVertices, polygon, PortalWasSplit, SplitPortal(), and PORTAL::Vertex.

Referenced by FindTruePortals().

00880 {
00881     int result, returnvalue = 0;
00882     for (int polygon = 0; polygon < portal->backleaf->numpolys; polygon++)
00883     {
00884         PORTAL* front = new PORTAL;
00885         PORTAL* back = new PORTAL;
00886         result = SplitPortal(portal, portal->backleaf->nodepolylist[polygon], front, back);
00887 
00888         if (result == PortalWasSplit)
00889         {
00890             returnvalue = PortalWasSplit;
00891             delete[] back->Vertex;
00892             back->Vertex = 0;
00893             delete back;
00894             delete[] portal->Vertex;
00895             portal->Vertex = 0;
00896             portal->numVertices = front->numVertices;
00897             portal->Vertex = front->Vertex;
00898             delete front;
00899         }
00900         else
00901         {
00902             delete back;
00903             delete front;
00904         }
00905     }
00906     return returnvalue;
00907 }

int ClipPortalToFrontLeaf PORTAL   portal
 

Definition at line 848 of file portal.cpp.

References PORTAL::frontleaf, BSP_node::nodepolylist, BSP_node::numpolys, PORTAL::numVertices, polygon, PortalWasSplit, SplitPortal(), and PORTAL::Vertex.

Referenced by FindTruePortals().

00849 {
00850     int result, returnvalue = 0;
00851     for (int polygon = 0; polygon < portal->frontleaf->numpolys; polygon++)
00852     {
00853         PORTAL* front = new PORTAL;
00854         PORTAL* back = new PORTAL;
00855         result = SplitPortal(portal, portal->frontleaf->nodepolylist[polygon], front, back);
00856 
00857         if (result == PortalWasSplit)
00858         {
00859             returnvalue = PortalWasSplit;
00860             delete[] back->Vertex;
00861             back->Vertex = 0;
00862             delete back;
00863             delete[] portal->Vertex;
00864             portal->Vertex = 0;
00865             portal->numVertices = front->numVertices; 
00866             portal->Vertex = front->Vertex;
00867             delete front;
00868         }
00869 
00870         else
00871         {
00872             delete back;
00873             delete front;
00874         }
00875     }
00876     return returnvalue;
00877 }

PORTAL* CopyPortal PORTAL   portal
 

Definition at line 86 of file portal.cpp.

References PORTAL::numVertices, and PORTAL::Vertex.

Referenced by AddPortal(), AddPortalsToLeaves(), and InvertPortal().

00087 {
00088     PORTAL* tempportal = new PORTAL;
00089     *tempportal = *portal;
00090     tempportal->Vertex = new VERTEX[portal->numVertices];
00091     for (int loop = 0; loop < portal->numVertices; loop++)
00092         tempportal->Vertex[loop] = portal->Vertex[loop];
00093     return tempportal;
00094 }

void CreateLargePortal POLYGON    splittingPolygon,
PORTAL   largePortal
 

Definition at line 96 of file portal.cpp.

References POLYGON::GetNormal(), Max_X, Max_Y, Max_Z, Min_X, Min_Y, Min_Z, VECTOR::Normalize(), PORTAL::numVertices, PORTAL::SetNormal(), POLYGON::Vertex, PORTAL::Vertex, VERTEX::x, VECTOR::x, VERTEX::y, VECTOR::y, VERTEX::z, and VECTOR::z.

Referenced by MakePortalList().

00097 {
00098 // Make large portal using planar mapping
00099     largePortal->numVertices = 4;
00100     largePortal->Vertex = new VERTEX[4];
00101     // find the primary axis plane
00102     int flag = 0;
00103     VECTOR poly_normal = splittingPolygon.GetNormal();
00104     poly_normal.Normalize();
00105 
00106     if (fabs(poly_normal.x) > fabs(poly_normal.y) && fabs(poly_normal.x) > fabs(poly_normal.z))
00107     {
00108         flag = 1;
00109         largePortal->Vertex[0].y = Min_Y;
00110         largePortal->Vertex[0].z = Max_Z;
00111         largePortal->Vertex[1].y = Min_Y;
00112         largePortal->Vertex[1].z = Min_Z;
00113         largePortal->Vertex[2].y = Max_Y;
00114         largePortal->Vertex[2].z = Min_Z;
00115         largePortal->Vertex[3].y = Max_Y;
00116         largePortal->Vertex[3].z = Max_Z;
00117     }
00118     else if (fabs(poly_normal.y) > fabs(poly_normal.x) && fabs(poly_normal.y) > fabs(poly_normal.z))
00119     {
00120         flag = 2;
00121         largePortal->Vertex[0].x = Min_X;
00122         largePortal->Vertex[0].z = Max_Z;
00123         largePortal->Vertex[1].x = Max_X;
00124         largePortal->Vertex[1].z = Max_Z;
00125         largePortal->Vertex[2].x = Max_X;
00126         largePortal->Vertex[2].z = Min_Z;
00127         largePortal->Vertex[3].x = Min_X;
00128         largePortal->Vertex[3].z = Min_Z;
00129     }
00130     else
00131     {
00132         flag = 3;
00133         largePortal->Vertex[0].x = Min_X;
00134         largePortal->Vertex[0].y = Min_Y;
00135         largePortal->Vertex[1].x = Max_X;
00136         largePortal->Vertex[1].y = Min_Y;
00137         largePortal->Vertex[2].x = Max_X;
00138         largePortal->Vertex[2].y = Max_Y;
00139         largePortal->Vertex[3].x = Min_X;
00140         largePortal->Vertex[3].y = Max_Y;
00141     }
00142 
00143     float X, Y, Z;
00144     float Distance = - (poly_normal.x * splittingPolygon.Vertex[0].x + poly_normal.y * splittingPolygon.Vertex[0].y + poly_normal.z * splittingPolygon.Vertex[0].z);
00145     switch (flag)
00146     {
00147         case 1: //YZ Plane
00148             X = - ( poly_normal.y * Min_Y + poly_normal.z * Max_Z + Distance ) / poly_normal.x;
00149             largePortal->Vertex[0].x = X;
00150             X = - ( poly_normal.y * Min_Y + poly_normal.z * Min_Z + Distance ) / poly_normal.x;
00151             largePortal->Vertex[1].x = X;
00152             X = - ( poly_normal.y * Max_Y + poly_normal.z * Min_Z + Distance ) / poly_normal.x;
00153             largePortal->Vertex[2].x = X;
00154             X = - ( poly_normal.y * Max_Y + poly_normal.z * Max_Z + Distance ) / poly_normal.x;
00155             largePortal->Vertex[3].x = X;
00156         break;
00157         case 2: //XZ Plane
00158             Y = - ( poly_normal.x * Min_X + poly_normal.z * Max_Z + Distance ) / poly_normal.y;
00159             largePortal->Vertex[0].y = Y;
00160             Y = - ( poly_normal.x * Max_X + poly_normal.z * Max_Z + Distance ) / poly_normal.y;
00161             largePortal->Vertex[1].y = Y;
00162             Y = - ( poly_normal.x * Max_X + poly_normal.z * Min_Z + Distance ) / poly_normal.y;
00163             largePortal->Vertex[2].y = Y;
00164             Y = - ( poly_normal.x * Min_X + poly_normal.z * Min_Z + Distance ) / poly_normal.y;
00165             largePortal->Vertex[3].y = Y;
00166         break;
00167         case 3: //XY Plane
00168             Z = - ( poly_normal.x * Min_X + poly_normal.y * Min_Y + Distance ) / poly_normal.z;
00169             largePortal->Vertex[0].z = Z;
00170             Z = - ( poly_normal.x * Max_X + poly_normal.y * Min_Y + Distance ) / poly_normal.z;
00171             largePortal->Vertex[1].z = Z;
00172             Z = - ( poly_normal.x * Max_X + poly_normal.y * Max_Y + Distance ) / poly_normal.z;
00173             largePortal->Vertex[2].z = Z;
00174             Z = - ( poly_normal.x * Min_X + poly_normal.y * Max_Y + Distance ) / poly_normal.z;
00175             largePortal->Vertex[3].z = Z;
00176         break;
00177     }
00178     largePortal->SetNormal();
00179 }

void FindTruePortals BSP_node   node
 

Definition at line 955 of file portal.cpp.

References BSP_node::backnode, CheckForSinglePortals(), ClipPortalToBackLeaf(), ClipPortalToFrontLeaf(), LinkedList< PORTAL >::Delete(), BSP_node::frontnode, LinkedList< PORTAL >::Get(), InvertPortals(), BSP_node::leaf, BSP_node::numportals, BSP_node::portallist, RemoveExtraPortals(), and PORTAL::Vertex.

Referenced by InitGL().

00956 {
00957     int flag;
00958     if (node->leaf == true)
00959     {
00960         for (int portalnumber = node->numportals; portalnumber > 0; portalnumber--)
00961         {
00962             flag = 0;
00963             PORTAL* tempportal = node->portallist.Get(portalnumber);
00964             CheckForSinglePortals(root, node, tempportal, &flag);
00965             if (flag == 0)
00966             {
00967                 delete[] tempportal->Vertex;
00968                 tempportal->Vertex = 0;
00969                 node->portallist.Delete(portalnumber);
00970                 delete tempportal;
00971                 node->numportals--;
00972             }
00973             else
00974             {
00975                 ClipPortalToFrontLeaf(tempportal);
00976                 ClipPortalToBackLeaf(tempportal);
00977             }
00978         }
00979 
00980         InvertPortals(node);    // also inverts the front and back leaf pointers if necessary
00981 
00982         for (int portalnumber = node->numportals; portalnumber > 0; portalnumber--)
00983         {
00984             PORTAL* tempportal = node->portallist.Get(portalnumber);
00985             flag = RemoveExtraPortals(tempportal);
00986             if (flag == true)
00987             {
00988                 delete[] tempportal->Vertex;
00989                 tempportal->Vertex = 0;
00990                 node->portallist.Delete(portalnumber);
00991                 delete tempportal;
00992                 node->numportals--;
00993             }
00994         }
00995         return;
00996     }
00997     else
00998     {
00999         FindTruePortals(node->frontnode);
01000         FindTruePortals(node->backnode);
01001         return;
01002     }
01003 }

void InvertPortal PORTAL   portal
 

Definition at line 747 of file portal.cpp.

References CopyPortal(), PORTAL::numVertices, and PORTAL::Vertex.

Referenced by InvertPortals().

00748 {
00749     PORTAL* tempportal = CopyPortal(portal);
00750     int numverts = portal->numVertices;
00751     for (int loop = 0; loop < numverts; loop++)
00752         portal->Vertex[loop] = tempportal->Vertex[(numverts - 1) - loop];
00753     delete[] tempportal->Vertex;
00754     tempportal->Vertex = 0;
00755     delete tempportal;
00756     return;
00757 }

void InvertPortals BSP_node   node
 

Definition at line 759 of file portal.cpp.

References PORTAL::backleaf, ClassifyPoint(), CrossVector(), PORTAL::frontleaf, LinkedList< PORTAL >::Get(), InvertPortal(), BSP_node::nodeid, BSP_node::nodepolylist, BSP_node::numpolys, BSP_node::numportals, polygon, BSP_node::portallist, POLYGON::Vertex, PORTAL::Vertex, VERTEX::x, VECTOR::x, VERTEX::y, VECTOR::y, VERTEX::z, and VECTOR::z.

Referenced by FindTruePortals().

00760 {
00761     VECTOR planeNormal, polysNormal, pointOnPlane, edge1, edge2, temp;
00762     int flag;
00763     for (int loop = 1; loop <= node->numportals; loop++)
00764     {
00765         PORTAL* tempportal = node->portallist.Get(loop);
00766         // get a point on the plane
00767         pointOnPlane.x = tempportal->Vertex[0].x;
00768         pointOnPlane.y = tempportal->Vertex[0].y;
00769         pointOnPlane.z = tempportal->Vertex[0].z;
00770 
00771         // get the normal of the portals plane
00772         edge1.x = tempportal->Vertex[1].x - tempportal->Vertex[0].x;
00773         edge1.y = tempportal->Vertex[1].y - tempportal->Vertex[0].y;
00774         edge1.z = tempportal->Vertex[1].z - tempportal->Vertex[0].z;
00775         edge2.x = tempportal->Vertex[2].x - tempportal->Vertex[0].x;
00776         edge2.y = tempportal->Vertex[2].y - tempportal->Vertex[0].y;
00777         edge2.z = tempportal->Vertex[2].z - tempportal->Vertex[0].z;
00778         planeNormal = CrossVector(edge1, edge2);
00779 
00780         flag = 0;
00781         for (int polygon = 0; polygon < node->numpolys; polygon++)
00782         {
00783             for (int vert = 0; vert < 3; vert++)
00784             {
00785                 temp.x = node->nodepolylist[polygon].Vertex[vert].x;
00786                 temp.y = node->nodepolylist[polygon].Vertex[vert].y;
00787                 temp.z = node->nodepolylist[polygon].Vertex[vert].z;
00788 
00789                 flag = ClassifyPoint(temp, pointOnPlane, planeNormal);
00790                 if (flag == -1)
00791                 {
00792                     InvertPortal(tempportal);
00793                 }
00794                 if (flag == 1 || flag == -1)
00795                 {
00796                     if (tempportal->frontleaf->nodeid != node->nodeid)
00797                     {
00798                         BSP_node* tempnode = tempportal->backleaf;
00799                         tempportal->backleaf = tempportal->frontleaf;
00800                         tempportal->frontleaf = tempnode;
00801                     }
00802                     break;
00803                 }
00804             }
00805             if (flag == 1 || flag == -1)
00806                 break;
00807         }
00808     }
00809 }

void MakePortalList  
 

Definition at line 533 of file portal.cpp.

References CreateLargePortal(), LinkedList< T >::Delete(), LinkedList< T >::Get(), LinkedList< T >::Insert(), PORTAL::linkPosition, ListNode::node, numpartitions, numportals, BSP_node::partition, PORTAL::PartitionNodeId, PORTAL::PortalId, PortalWasSplit, SplitPortal(), and PORTAL::Vertex.

Referenced by InitGL().

00534 {
00535     // Create the large portals
00536     for (int loop = 1; loop <= numpartitions; loop++)
00537     {
00538         listnode = PartitionList.Get(loop);
00539         portal = new PORTAL;
00540         portal->Vertex = 0;
00541         portal->linkPosition = loop;
00542         portal->PartitionNodeId = loop;
00543         CreateLargePortal(listnode->node->partition, portal);
00544         PortalList.Insert(portal);
00545     }
00546 
00547     // Split the large portals into potential portals
00548     numportals = numpartitions;
00549     int result, portalToSplit;
00550     PORTAL* frontportal;
00551     PORTAL* backportal;
00552     for (int partition = 1; partition <= numpartitions; partition++)
00553     {
00554         listnode = PartitionList.Get(partition);
00555         portalToSplit = numportals;
00556         while (portalToSplit > 0)
00557         {
00558             frontportal = new PORTAL;
00559             backportal = new PORTAL;
00560 
00561             portal = PortalList.Get(portalToSplit);
00562             result = SplitPortal(portal, listnode->node->partition, frontportal, backportal);
00563 
00564             if (result == PortalWasSplit)
00565             {
00566                 frontportal->PartitionNodeId = portal->PartitionNodeId;
00567                 backportal->PartitionNodeId = portal->PartitionNodeId;
00568 
00569                 delete[] portal->Vertex;
00570                 portal->Vertex = 0;
00571                 PortalList.Delete(portalToSplit);
00572                 delete portal;
00573                 numportals--;
00574 
00575                 frontportal->linkPosition = ++numportals;
00576                 PortalList.Insert(frontportal);
00577                 backportal->linkPosition = ++numportals;
00578                 PortalList.Insert(backportal);
00579             }
00580             else
00581             {
00582                 delete frontportal;
00583                 delete backportal;
00584             }
00585             portalToSplit--;
00586         }
00587     }
00588 
00589     // Loop through the portals and assign a unique id
00590     for (int loop = 1; loop <= numportals; loop++)
00591     {
00592         portal = PortalList.Get(loop);
00593         portal->PortalId = loop;
00594     }
00595 }

int RemoveExtraPortals PORTAL   portal
 

Definition at line 937 of file portal.cpp.

References PORTAL::backleaf, ClassifyInvertedPortal(), Front, BSP_node::nodepolylist, and BSP_node::numpolys.

Referenced by FindTruePortals().

00938 {
00939     int result, count = 0;
00940     POLYGON temppoly;
00941     BSP_node* tempnode = portal->backleaf;
00942     for (int loop = 0; loop < tempnode->numpolys; loop++)
00943     {
00944         temppoly = tempnode->nodepolylist[loop];
00945         result = ClassifyInvertedPortal(portal, temppoly);
00946         if (result == Front)
00947             count++;
00948     }
00949     if (count != portal->backleaf->numpolys)
00950         return true;
00951     else
00952         return false;
00953 }

int SplitPortal PORTAL   portalToSplit,
POLYGON    planePolygon,
PORTAL   front,
PORTAL   back
 

Referenced by CalculatePVS(), ClipPortalToBackLeaf(), ClipPortalToFrontLeaf(), FindVisibleLeaves(), and MakePortalList().

int SplitPortal PORTAL   portalToSplit,
PLANE    plane,
VECTOR    pointOnPlane,
PORTAL   front,
PORTAL   back
 


Generated on Fri Dec 23 05:19:58 2005 for Particles by doxygen1.2.15