- build system has to use 32bit (the code is not 64bit safe)
[genesis3d.git] / GBSPLib / PORTALS.CPP
1 /****************************************************************************************/\r
2 /*  Portals.cpp                                                                         */\r
3 /*                                                                                      */\r
4 /*  Author: John Pollard                                                                */\r
5 /*  Description: Creates and manages portals (passages from leaf-to-leaf)               */\r
6 /*                                                                                      */\r
7 /*  The contents of this file are subject to the Genesis3D Public License               */\r
8 /*  Version 1.01 (the "License"); you may not use this file except in                   */\r
9 /*  compliance with the License. You may obtain a copy of the License at                */\r
10 /*  http://www.genesis3d.com                                                            */\r
11 /*                                                                                      */\r
12 /*  Software distributed under the License is distributed on an "AS IS"                 */\r
13 /*  basis, WITHOUT WARRANTY OF ANY KIND, either express or implied.  See                */\r
14 /*  the License for the specific language governing rights and limitations              */\r
15 /*  under the License.                                                                  */\r
16 /*                                                                                      */\r
17 /*  The Original Code is Genesis3D, released March 25, 1999.                            */\r
18 /*Genesis3D Version 1.1 released November 15, 1999                            */\r
19 /*  Copyright (C) 1999 WildTangent, Inc. All Rights Reserved           */\r
20 /*                                                                                      */\r
21 /****************************************************************************************/\r
22 #include <Windows.h>\r
23 #include <Stdio.h>\r
24 #include <Assert.h>\r
25 \r
26 #include "Portals.h"\r
27 #include "Poly.h"\r
28 #include "Bsp.h"\r
29 #include "GBSPFile.h"\r
30 #include "Leaf.h"\r
31 #include "Utils.h"\r
32 #include "Map.h"\r
33 \r
34 #include "Ram.h"\r
35 \r
36 GBSP_Node       *OutsideNode;\r
37 geVec3d         NodeMins, NodeMaxs;\r
38 geBoolean       VisPortals;\r
39 \r
40 geBoolean CreateAllOutsidePortals(GBSP_Node *Node);\r
41 void GetNodeMinsMaxs(GBSP_Node *Node);\r
42 geBoolean AddPortalToNodes(GBSP_Portal *Portal, GBSP_Node *Front, GBSP_Node *Back);\r
43 geBoolean RemovePortalFromNode(GBSP_Portal *Portal, GBSP_Node *Node);\r
44 GBSP_Portal *AllocPortal(void);\r
45 \r
46 //=====================================================================================\r
47 //      CreatePolyOnNode\r
48 //=====================================================================================\r
49 geBoolean CreatePolyOnNode (GBSP_Node *Node, GBSP_Poly **Out)\r
50 {\r
51         GBSP_Poly       *Poly;\r
52         GBSP_Plane      *Plane;\r
53         GBSP_Node       *Parent;\r
54 \r
55         Poly = CreatePolyFromPlane(&Planes[Node->PlaneNum]);\r
56 \r
57         if (!Poly)\r
58         {\r
59                 GHook.Error("CreatePolyOnNode:  Could not create poly.\n");\r
60                 return GE_FALSE;\r
61         }\r
62 \r
63         // Clip this portal by all the parents of this node\r
64         for (Parent = Node->Parent ; Parent && Poly ; )\r
65         {\r
66                 geBoolean       Side;\r
67 \r
68                 Plane = &Planes[Parent->PlaneNum];\r
69 \r
70                 Side = (Parent->Children[0] == Node) ? GE_FALSE : GE_TRUE;\r
71                         \r
72                 if (!ClipPolyEpsilon(Poly, 0.001f, Plane, Side, &Poly))\r
73                         return GE_FALSE;\r
74 \r
75                 Node = Parent;\r
76                 Parent = Parent->Parent;\r
77         }\r
78 \r
79         *Out = Poly;\r
80 \r
81         return GE_TRUE;\r
82 }\r
83 \r
84 //=====================================================================================\r
85 //      CreatePortals\r
86 //=====================================================================================\r
87 geBoolean CreatePortals(GBSP_Node *RootNode, GBSP_Model *Model, geBoolean Vis)\r
88 {\r
89         if (Verbose)\r
90                 GHook.Printf(" --- Create Portals --- \n");\r
91 \r
92         VisPortals = Vis;\r
93 \r
94         OutsideNode = &Model->OutsideNode;\r
95 \r
96         NodeMins = Model->Mins;\r
97         NodeMaxs = Model->Maxs;\r
98 \r
99         if (!CreateAllOutsidePortals(RootNode))\r
100         {\r
101                 GHook.Error("CreatePortals:  Could not create bbox portals.\n");\r
102                 return GE_FALSE;\r
103         }\r
104 \r
105         if (!PartitionPortals_r(RootNode))\r
106         {\r
107                 GHook.Error("CreatePortals:  Could not partition portals.\n");\r
108                 return GE_FALSE;\r
109         }\r
110 \r
111         return GE_TRUE;\r
112 }\r
113 \r
114 //=====================================================================================\r
115 //      CreateOutsidePortal\r
116 //=====================================================================================\r
117 GBSP_Portal *CreateOutsidePortal(GBSP_Plane *Plane, GBSP_Node *Node)\r
118 {\r
119         GBSP_Portal     *NewPortal;\r
120         int32           Side;\r
121 \r
122         NewPortal = AllocPortal();\r
123         if (!NewPortal)\r
124                 return NULL;\r
125 \r
126         NewPortal->Poly = CreatePolyFromPlane(Plane);\r
127         if (!NewPortal->Poly)\r
128         {\r
129                 return NULL;\r
130         }\r
131         NewPortal->PlaneNum = FindPlane(Plane, &Side);\r
132 \r
133         if (NewPortal->PlaneNum == -1)\r
134         {\r
135                 GHook.Error("CreateOutsidePortal:  Could not create plane.\n");\r
136                 return NULL;\r
137         }\r
138 \r
139         if (!Side)\r
140         {\r
141                 if (!AddPortalToNodes(NewPortal, Node, OutsideNode))\r
142                         return NULL;\r
143         }\r
144         else\r
145         {\r
146                 if (!AddPortalToNodes(NewPortal, OutsideNode, Node))\r
147                         return NULL;\r
148         }\r
149 \r
150         return NewPortal;\r
151 }\r
152 \r
153 //=====================================================================================\r
154 //      CreateAllOutsidePortals\r
155 //=====================================================================================\r
156 geBoolean CreateAllOutsidePortals(GBSP_Node *Node)\r
157 {\r
158         int32           k, i, Index;\r
159         GBSP_Plane      PPlanes[6];\r
160         GBSP_Portal     *Portals[6];\r
161 \r
162         memset(OutsideNode, 0, sizeof(GBSP_Node));\r
163 \r
164         memset(PPlanes, 0, 6*sizeof(GBSP_Plane));\r
165 \r
166         OutsideNode->PlaneNum = PLANENUM_LEAF;\r
167         OutsideNode->Contents = BSP_CONTENTS_SOLID2;\r
168         OutsideNode->Portals = NULL;\r
169         OutsideNode->BrushList = NULL;\r
170 \r
171         // So there won't be NULL volume leafs when we create the outside portals\r
172         for (k=0; k< 3; k++)\r
173         {\r
174                 if (VectorToSUB(NodeMins, k)-128 <= -MIN_MAX_BOUNDS || VectorToSUB(NodeMaxs, k)+128 >= MIN_MAX_BOUNDS)\r
175                 {\r
176                         GHook.Error("CreateAllOutsidePortals:  World BOX out of range...\n");\r
177                         return GE_FALSE;\r
178                 }\r
179 \r
180                 VectorToSUB(NodeMins, k) -= (geFloat)128;\r
181                 VectorToSUB(NodeMaxs, k) += (geFloat)128;\r
182         }\r
183 \r
184         // Create 6 portals, and point to the outside and the RootNode\r
185         for (i=0; i<3; i++)\r
186         {\r
187                 for (k=0; k<2; k++)\r
188                 {\r
189                         Index = k*3 + i;\r
190                         geVec3d_Clear(&PPlanes[Index].Normal);\r
191 \r
192                         if (k == 0)\r
193                         {\r
194                                 VectorToSUB(PPlanes[Index].Normal, i) = (geFloat)1;\r
195                                 PPlanes[Index].Dist = VectorToSUB(NodeMins, i);\r
196                         }\r
197                         else\r
198                         {\r
199                                 VectorToSUB(PPlanes[Index].Normal, i) = (geFloat)-1;\r
200                                 PPlanes[Index].Dist = -VectorToSUB(NodeMaxs, i);\r
201                         }\r
202                         \r
203                         Portals[Index] = CreateOutsidePortal(&PPlanes[Index], Node);\r
204                         if (!Portals[Index])\r
205                                 return GE_FALSE;\r
206                 }\r
207         }\r
208                                                           \r
209         for (i=0; i< 6; i++)\r
210         {\r
211                 for (k=0; k< 6; k++)\r
212                 {\r
213                         if (k == i)\r
214                                 continue;\r
215 \r
216                         if (!ClipPoly(Portals[i]->Poly, &PPlanes[k], GE_FALSE, &Portals[i]->Poly))\r
217                         {\r
218                                 GHook.Error("CreateAllOutsidePortals:  There was an error clipping the portal.\n");\r
219                                 return GE_FALSE;\r
220                         }\r
221 \r
222                         if (!Portals[i]->Poly)\r
223                         {\r
224                                 GHook.Error("CreateAllOutsidePortals:  Portal was clipped away.\n");\r
225                                 return GE_FALSE;\r
226                         }\r
227                 }\r
228         }\r
229 \r
230         return GE_TRUE;\r
231 }\r
232 \r
233 //=====================================================================================\r
234 //      CheckPortal\r
235 //=====================================================================================\r
236 geBoolean CheckPortal(GBSP_Portal *Portal)\r
237 {\r
238         GBSP_Poly       *Poly;\r
239         geVec3d         *Verts;\r
240         int32           i, k;\r
241         geFloat         Val;\r
242 \r
243         Poly = Portal->Poly;\r
244         Verts = Poly->Verts;\r
245 \r
246         if (Poly->NumVerts < 3)\r
247         {\r
248                 GHook.Error("CheckPortal:  NumVerts < 3.\n");\r
249                 return GE_FALSE;\r
250         }\r
251 \r
252         for (i=0; i< Poly->NumVerts; i++)\r
253         {\r
254                 for (k=0; k<3; k++)\r
255                 {\r
256                         Val = VectorToSUB(Verts[i], k);\r
257 \r
258                         if (Val == MIN_MAX_BOUNDS)\r
259                         {\r
260                                 GHook.Error("CheckPortal:  Portal was not clipped on all sides!!!\n");\r
261                                 return GE_FALSE;\r
262                         }\r
263                 \r
264                         if (Val == -MIN_MAX_BOUNDS)\r
265                         {\r
266                                 GHook.Error("CheckPortal:  Portal was not clipped on all sides!!!\n");\r
267                                 return GE_FALSE;\r
268                         }\r
269                 }\r
270         }\r
271 \r
272         return GE_TRUE;\r
273 }\r
274 \r
275 //=======================================================================================\r
276 //      CalcNodeBoundsFromPortals\r
277 //      Calcs bounds for nodes, and leafs\r
278 //=======================================================================================\r
279 void CalcNodeBoundsFromPortals(GBSP_Node *Node)\r
280 {\r
281         GBSP_Portal             *p;\r
282         int32                   s, i;\r
283 \r
284         ClearBounds(&Node->Mins, &Node->Maxs);\r
285 \r
286         for (p=Node->Portals; p; p = p->Next[s])\r
287         {\r
288                 s = (p->Nodes[1] == Node);\r
289 \r
290                 for (i=0; i<p->Poly->NumVerts; i++)\r
291                         AddPointToBounds(&p->Poly->Verts[i], &Node->Mins, &Node->Maxs);\r
292         }\r
293 }\r
294 \r
295 //=====================================================================================\r
296 //      PartitionPortals_r\r
297 //=====================================================================================\r
298 geBoolean PartitionPortals_r(GBSP_Node *Node)\r
299 {\r
300         GBSP_Poly               *NewPoly, *FPoly, *BPoly;\r
301         GBSP_Plane              *pPlane, *pPlane2;\r
302         GBSP_Portal             *Portal, *NewPortal, *Next;\r
303         GBSP_Node               *Front, *Back, *OtherNode;\r
304         int32                   Side;\r
305 \r
306         CalcNodeBoundsFromPortals(Node);\r
307 \r
308         if (Node->PlaneNum == PLANENUM_LEAF)\r
309                 return GE_TRUE;\r
310 \r
311         if (VisPortals && Node->Detail)                 // We can stop at detail seperators for the vis tree\r
312                 return GE_TRUE;\r
313 \r
314         //if (!InitializeNodePortal(Node))\r
315         //      return GE_FALSE;\r
316         //if (!DistributeNodePortalsToChildren(Node))\r
317         //      return GE_FALSE;\r
318 \r
319         Front = Node->Children[0];\r
320         Back = Node->Children[1];\r
321 \r
322         pPlane = &Planes[Node->PlaneNum];\r
323 \r
324         // Create a new portal\r
325         if (!CreatePolyOnNode (Node, &NewPoly))\r
326         {\r
327                 GHook.Error("PartitionPortals_r:  CreatePolyOnNode failed.\n");\r
328                 return GE_FALSE;\r
329         }\r
330 \r
331         // Clip it against all other portals attached to this node\r
332         for (Portal = Node->Portals; Portal && NewPoly; Portal = Portal->Next[Side])\r
333         {\r
334                 if (Portal->Nodes[0] == Node)\r
335                         Side = 0;\r
336                 else if (Portal->Nodes[1] == Node)\r
337                         Side = 1;\r
338                 else\r
339                 {\r
340                         GHook.Error("PartitionPortals_r:  Portal does not look at either node.\n");\r
341                         return GE_FALSE;\r
342                 }\r
343 \r
344                 pPlane2 = &Planes[Portal->PlaneNum];\r
345 \r
346                 if (!ClipPolyEpsilon(NewPoly, 0.001f, pPlane2, Side, &NewPoly))\r
347                 {\r
348                         GHook.Error("PartitionPortals_r:  There was an error clipping the poly.\n");\r
349                         return GE_FALSE;\r
350                 }\r
351 \r
352                 if (!NewPoly)\r
353                 {\r
354                         GHook.Printf("PartitionPortals_r:  Portal was cut away.\n");\r
355                         break;\r
356                 }\r
357         }\r
358         \r
359         if (NewPoly && PolyIsTiny (NewPoly))\r
360         {\r
361                 FreePoly(NewPoly);\r
362                 NewPoly = NULL;\r
363         }\r
364 \r
365         if (NewPoly)\r
366         {\r
367                 NewPortal = AllocPortal();\r
368                 if (!NewPortal)\r
369                 {\r
370                         GHook.Error("PartitionPortals_r:  Out of memory for portal.\n");\r
371                         return GE_FALSE;\r
372                 }\r
373                 NewPortal->Poly = NewPoly;\r
374                 NewPortal->PlaneNum = Node->PlaneNum;\r
375                 NewPortal->OnNode = Node;\r
376 \r
377                 if (!CheckPortal(NewPortal))\r
378                 {\r
379                         GHook.Error("PartiionPortals_r:  Check Portal failed.\n");\r
380                         return GE_FALSE;\r
381                 }\r
382                 else\r
383                         AddPortalToNodes(NewPortal, Front, Back);\r
384 \r
385         }\r
386         \r
387         // Partition all portals by this node\r
388         for (Portal = Node->Portals; Portal; Portal = Next)\r
389         {\r
390                 if (Portal->Nodes[0] == Node)\r
391                         Side = 0;\r
392                 else if (Portal->Nodes[1] == Node)\r
393                         Side = 1;\r
394                 else\r
395                 {\r
396                         GHook.Error("PartitionPortals_r:  Portal does not look at either node.\n");\r
397                         return GE_FALSE;\r
398                 }\r
399 \r
400                 Next = Portal->Next[Side];\r
401                 \r
402                 // Remember the node on the back side\r
403                 OtherNode = Portal->Nodes[!Side];\r
404                 RemovePortalFromNode(Portal, Portal->Nodes[0]);\r
405                 RemovePortalFromNode(Portal, Portal->Nodes[1]);\r
406 \r
407                 if (!SplitPolyEpsilon(Portal->Poly, 0.001f, pPlane, &FPoly, &BPoly, GE_FALSE))\r
408                 {\r
409                         GHook.Error("PartitionPortals_r:  Could not split portal.\n");\r
410                         return GE_FALSE;\r
411                 }\r
412                 \r
413                 if (FPoly && PolyIsTiny(FPoly))\r
414                 {\r
415                         FreePoly(FPoly);\r
416                         FPoly = NULL;\r
417                 }\r
418 \r
419                 if (BPoly && PolyIsTiny(BPoly))\r
420                 {\r
421                         FreePoly(BPoly);\r
422                         BPoly = NULL;\r
423                 }\r
424                 \r
425                 if (!FPoly && !BPoly)\r
426                         continue;\r
427                 \r
428                 if (!FPoly)\r
429                 {\r
430                         Portal->Poly = BPoly;\r
431                         if (Side)\r
432                                 AddPortalToNodes(Portal, OtherNode, Back);\r
433                         else\r
434                                 AddPortalToNodes(Portal, Back, OtherNode);\r
435                         continue;\r
436                 }\r
437 \r
438                 if (!BPoly)\r
439                 {\r
440                         Portal->Poly = FPoly;\r
441                         if (Side)\r
442                                 AddPortalToNodes(Portal, OtherNode, Front);\r
443                         else\r
444                                 AddPortalToNodes(Portal, Front, OtherNode);\r
445                         continue;\r
446                 }\r
447 \r
448                 // Portal was split\r
449                 NewPortal = AllocPortal();\r
450                 if (!NewPortal)\r
451                 {\r
452                         GHook.Error("PartitionPortals_r:  Out of memory for portal.\n");\r
453                         return GE_FALSE;\r
454                 }\r
455                 Portal->Poly = FPoly;\r
456                 *NewPortal = *Portal;\r
457                 NewPortal->Poly = BPoly;\r
458                 \r
459                 if (Side)\r
460                 {\r
461                         AddPortalToNodes(Portal, OtherNode, Front);\r
462                         AddPortalToNodes(NewPortal, OtherNode, Back);\r
463                 }\r
464                 else\r
465                 {\r
466                         AddPortalToNodes(Portal, Front, OtherNode);\r
467                         AddPortalToNodes(NewPortal, Back, OtherNode);\r
468                 }\r
469         }\r
470 \r
471         if (Node->Portals != NULL)\r
472         {\r
473                 GHook.Printf("*WARNING* PartitionPortals_r:  Portals still on node after distribution...\n");\r
474         }\r
475         \r
476         if (!PartitionPortals_r(Front))\r
477                 return GE_FALSE;\r
478 \r
479         if (!PartitionPortals_r(Back))\r
480                 return GE_FALSE;\r
481 \r
482         return GE_TRUE;\r
483 }\r
484 \r
485 //=====================================================================================\r
486 //      AddPortalToNodes\r
487 //=====================================================================================\r
488 geBoolean AddPortalToNodes(GBSP_Portal *Portal, GBSP_Node *Front, GBSP_Node *Back)\r
489 {\r
490         if (Portal->Nodes[0] || Portal->Nodes[1])\r
491         {\r
492                 GHook.Error("LinkPortal:  Portal allready looks at one of the nodes.\n");\r
493                 return GE_FALSE;\r
494         }\r
495 \r
496         Portal->Nodes[0] = Front;\r
497         Portal->Next[0] = Front->Portals;\r
498         Front->Portals = Portal;\r
499 \r
500         Portal->Nodes[1] = Back;\r
501         Portal->Next[1] = Back->Portals;\r
502         Back->Portals = Portal;\r
503 \r
504         return GE_TRUE;\r
505 }\r
506 \r
507 //=====================================================================================\r
508 //      RemovePortalFromNode\r
509 //=====================================================================================\r
510 geBoolean RemovePortalFromNode(GBSP_Portal *Portal, GBSP_Node *Node)\r
511 {\r
512         GBSP_Portal     *p, **p2;\r
513         int32           Side;\r
514 \r
515         assert(Node->Portals);          // Better have some portals on this node\r
516         assert(!(Portal->Nodes[0] == Node && Portal->Nodes[1] == Node));\r
517         assert(Portal->Nodes[0] == Node || Portal->Nodes[1] == Node);   \r
518 \r
519         // Find the portal on this node\r
520         for (p2 = &Node->Portals, p = *p2; p; p2 = &p->Next[Side], p = *p2)\r
521         {\r
522                 assert(!(p->Nodes[0] == Node && p->Nodes[1] == Node));\r
523                 assert(p->Nodes[0] == Node || p->Nodes[1] == Node);\r
524 \r
525                 Side = (p->Nodes[1] == Node);   // Get the side of the portal that this node is on\r
526 \r
527                 if (p == Portal)\r
528                         break;                  // Got it\r
529         }\r
530          \r
531         assert(p && p2 && *p2);\r
532 \r
533         Side = (Portal->Nodes[1] == Node);      // Get the side of the portal that the node was on\r
534         \r
535         *p2 = Portal->Next[Side];\r
536         Portal->Nodes[Side] = NULL;\r
537 \r
538         return GE_TRUE;\r
539 }\r
540 \r
541 //=====================================================================================\r
542 //      AllocPortal\r
543 //=====================================================================================\r
544 GBSP_Portal *AllocPortal(void)\r
545 {\r
546         GBSP_Portal     *NewPortal;\r
547 \r
548         NewPortal = GE_RAM_ALLOCATE_STRUCT(GBSP_Portal);\r
549 \r
550         if (!NewPortal)\r
551         {\r
552                 GHook.Error("AllocPortal:  Out of memory!\n");\r
553                 return NULL;\r
554         }\r
555 \r
556         memset(NewPortal, 0, sizeof(GBSP_Portal));\r
557 \r
558         return NewPortal;\r
559 }\r
560 \r
561 //=====================================================================================\r
562 //      FreePortal\r
563 //=====================================================================================\r
564 geBoolean FreePortal(GBSP_Portal *Portal)\r
565 {\r
566         if (!Portal->Poly)\r
567         {\r
568                 GHook.Error("FreePortal:  Portal with NULL Poly.\n");\r
569                 return GE_FALSE;\r
570         }\r
571 \r
572         FreePoly(Portal->Poly);\r
573 \r
574         geRam_Free(Portal);\r
575 \r
576         return GE_TRUE;\r
577 }\r
578 \r
579 //=====================================================================================\r
580 //      FreePOrtals_r\r
581 //=====================================================================================\r
582 geBoolean FreePortals_r(GBSP_Node *Node)\r
583 {\r
584         GBSP_Portal *Portal, *Next;\r
585         int32           Side;\r
586 \r
587         if (!Node)\r
588                 return GE_TRUE;\r
589         \r
590         for (Portal = Node->Portals; Portal; Portal = Next)\r
591         {\r
592                 if (Portal->Nodes[0] == Node)\r
593                         Side = 0;\r
594                 else if (Portal->Nodes[1] == Node)\r
595                         Side = 1;\r
596                 else\r
597                 {\r
598                         GHook.Error("FreePortals_r:  Portal does not look at either node.\n");\r
599                         return GE_FALSE;\r
600                 }\r
601 \r
602                 Next = Portal->Next[Side];\r
603 \r
604                 if (!RemovePortalFromNode(Portal, Portal->Nodes[0]))\r
605                         return GE_FALSE;\r
606 \r
607                 if (!RemovePortalFromNode(Portal, Portal->Nodes[1]))\r
608                         return GE_FALSE;\r
609 \r
610                 if (!FreePortal(Portal))\r
611                         return GE_FALSE;\r
612         }\r
613 \r
614         Node->Portals = NULL;\r
615 \r
616         if (Node->PlaneNum == PLANENUM_LEAF)\r
617                 return GE_TRUE;\r
618 \r
619         if (!FreePortals_r(Node->Children[0]))\r
620                 return GE_FALSE;\r
621 \r
622         if (!FreePortals_r(Node->Children[1]))\r
623                 return GE_FALSE;\r
624 \r
625         return GE_TRUE;\r
626 }\r
627 \r
628 //=====================================================================================\r
629 //      FreePortals\r
630 //=====================================================================================\r
631 geBoolean FreePortals(GBSP_Node *RootNode)\r
632 {\r
633         return(FreePortals_r(RootNode));\r
634 }\r
635 \r
636 void AddPointToBounds(geVec3d *v, geVec3d *Mins, geVec3d *Maxs);\r
637 \r
638 //=====================================================================================\r
639 //      GetNodeMinsMaxs\r
640 //=====================================================================================\r
641 void GetNodeMinsMaxs(GBSP_Node *Node)\r
642 {\r
643         ClearBounds(&NodeMins, &NodeMaxs);\r
644 \r
645         NodeMins = Node->Mins;\r
646         NodeMaxs = Node->Maxs;\r
647 }\r
648 \r
649 //====================================================================================\r
650 //      GetLeafBBoxFromPortals\r
651 //====================================================================================\r
652 geBoolean GetLeafBBoxFromPortals(GBSP_Node *Node, geVec3d *Mins, geVec3d *Maxs)\r
653 {\r
654         GBSP_Poly       *Poly;\r
655         geVec3d         *Verts;\r
656         GBSP_Portal     *Portal;\r
657         int32           i, k, Side;\r
658 \r
659         if (Node->PlaneNum != PLANENUM_LEAF)\r
660         {\r
661                 GHook.Error("GetLeafBBoxFromPortals:  Not a leaf.\n");\r
662                 return GE_FALSE;\r
663         }\r
664 \r
665         ClearBounds(Mins, Maxs);\r
666 \r
667         for (Portal = Node->Portals; Portal; Portal = Portal->Next[Side])\r
668         {\r
669                 Side = (Portal->Nodes[1] == Node);\r
670 \r
671                 Poly = Portal->Poly;\r
672 \r
673                 Verts = Poly->Verts;\r
674                 for (i=0; i< Poly->NumVerts; i++)\r
675                 {\r
676                         for (k=0; k<3; k++)\r
677                         {\r
678                                 if (VectorToSUB(Verts[i], k) < VectorToSUB(*Mins, k))\r
679                                         VectorToSUB(*Mins, k) = VectorToSUB(Verts[i], k);\r
680                                 if (VectorToSUB(Verts[i], k) > VectorToSUB(*Maxs, k))\r
681                                         VectorToSUB(*Maxs, k) = VectorToSUB(Verts[i], k);\r
682                         }\r
683                 }\r
684         }\r
685 \r
686         return GE_TRUE;\r
687 }\r