nel/src/3d/zone.cpp

   1 // NeL - MMORPG Framework <http://dev.ryzom.com/projects/nel/>
   2 // Copyright (C) 2010  Winch Gate Property Limited
   3 //
   4 // This program is free software: you can redistribute it and/or modify
   5 // it under the terms of the GNU Affero General Public License as
   6 // published by the Free Software Foundation, either version 3 of the
   7 // License, or (at your option) any later version.
   8 //
   9 // This program is distributed in the hope that it will be useful,
  10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 // GNU Affero General Public License for more details.
  13 //
  14 // You should have received a copy of the GNU Affero General Public License
  15 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
  16
  17 #include "std3d.h"
  18
  19 #include "nel/3d/zone.h"
  20 #include "nel/3d/landscape.h"
  21 #include "nel/3d/zone_symmetrisation.h"
  22 #include "nel/misc/common.h"
  23 #include "nel/misc/hierarchical_timer.h"
  24
  25
  26 using namespace NLMISC;
  27 using namespace std;
  28
  29
  30 // define it only for debug bind.
  31 //#define       NL3D_DEBUG_DONT_BIND_PATCH
  32
  33 #ifdef DEBUG_NEW
  34 #define new DEBUG_NEW
  35 #endif
  36
  37 namespace NL3D
  38 {
  39
  40
  41
  42 // ***************************************************************************
  43 // ***************************************************************************
  44 // CPatchInfo
  45 // ***************************************************************************
  46 // ***************************************************************************
  47
  48
  49 // ***************************************************************************
  50 void                    CPatchInfo::setCornerSmoothFlag(uint corner, bool smooth)
  51 {
  52         nlassert(corner<=3);
  53         uint    mask= 1<<corner;
  54         if(smooth)
  55                 _CornerSmoothFlag|= mask;
  56         else
  57                 _CornerSmoothFlag&= ~mask;
  58 }
  59
  60 // ***************************************************************************
  61 bool                    CPatchInfo::getCornerSmoothFlag(uint corner) const
  62 {
  63         nlassert(corner<=3);
  64         uint    mask= 1<<corner;
  65         return  (_CornerSmoothFlag & mask)!=0;
  66 }
  67
  68
  69 // ***************************************************************************
  70 // ***************************************************************************
  71 // CZone
  72 // ***************************************************************************
  73 // ***************************************************************************
  74
  75
  76 // ***************************************************************************
  77 CZone::CZone()
  78 {
  79         ZoneId= 0;
  80         Compiled= false;
  81         Landscape= NULL;
  82         ClipResult= ClipOut;
  83 }
  84 // ***************************************************************************
  85 CZone::~CZone()
  86 {
  87         // release() must have been called.
  88         nlassert(!Compiled);
  89 }
  90
  91
  92 // ***************************************************************************
  93 void                    CZone::computeBBScaleBias(const CAABBox &bb)
  94 {
  95         ZoneBB= bb;
  96         // Take a security for noise. (useful for zone clipping).
  97         ZoneBB.setHalfSize(ZoneBB.getHalfSize()+CVector(NL3D_NOISE_MAX, NL3D_NOISE_MAX, NL3D_NOISE_MAX));
  98         CVector hs= ZoneBB.getHalfSize();
  99         float   rmax= maxof(hs.x, hs.y, hs.z);
 100         PatchScale= rmax / 32760;               // Prevent from float imprecision by taking 32760 and not 32767.
 101         PatchBias= ZoneBB.getCenter();
 102 }
 103
 104
 105 // ***************************************************************************
 106 void                    CZone::build(uint16 zoneId, const std::vector<CPatchInfo> &patchs, const std::vector<CBorderVertex> &borderVertices, uint32 numVertices)
 107 {
 108         CZoneInfo       zinfo;
 109         zinfo.ZoneId= zoneId;
 110         zinfo.Patchs= patchs;
 111         zinfo.BorderVertices= borderVertices;
 112
 113         build(zinfo, numVertices);
 114 }
 115 // ***************************************************************************
 116 void                    CZone::build(const CZoneInfo &zoneInfo, uint32 numVertices)
 117 {
 118         sint    i,j;
 119         nlassert(!Compiled);
 120
 121         // Ref inupt
 122         uint16          zoneId= zoneInfo.ZoneId;
 123         const std::vector<CPatchInfo> &patchs= zoneInfo.Patchs;
 124         const std::vector<CBorderVertex> &borderVertices= zoneInfo.BorderVertices;
 125
 126
 127         ZoneId= zoneId;
 128         BorderVertices= borderVertices;
 129
 130         // Compute the bbox and the bias/scale.
 131         //=====================================
 132         CAABBox         bb;
 133         if(!patchs.empty())
 134                 bb.setCenter(patchs[0].Patch.Vertices[0]);
 135         bb.setHalfSize(CVector::Null);
 136         for(j=0;j<(sint)patchs.size();j++)
 137         {
 138                 const CBezierPatch      &p= patchs[j].Patch;
 139                 for(i=0;i<4;i++)
 140                         bb.extend(p.Vertices[i]);
 141                 for(i=0;i<8;i++)
 142                         bb.extend(p.Tangents[i]);
 143                 for(i=0;i<4;i++)
 144                         bb.extend(p.Interiors[i]);
 145         }
 146         // Compute BBox, and Patch Scale Bias, according to Noise.
 147         computeBBScaleBias(bb);
 148
 149
 150         // Compute/compress Patchs.
 151         //=========================
 152         Patchs.resize(patchs.size());
 153         PatchConnects.resize(patchs.size());
 154         sint    maxVertex=-1;
 155         for(j=0;j<(sint)patchs.size();j++)
 156         {
 157                 const CPatchInfo        &pi= patchs[j];
 158                 const CBezierPatch      &p= pi.Patch;
 159                 CPatch                          &pa= Patchs[j];
 160                 CPatchConnect           &pc= PatchConnects[j];
 161
 162                 // Smoothing flags
 163                 pa.Flags&=~NL_PATCH_SMOOTH_FLAG_MASK;
 164                 pa.Flags|=NL_PATCH_SMOOTH_FLAG_MASK&(pi.Flags<<NL_PATCH_SMOOTH_FLAG_SHIFT);
 165
 166
 167                 // Noise Data
 168                 // copy noise rotation.
 169                 pa.NoiseRotation= pi.NoiseRotation;
 170                 // copy all noise smoothing info.
 171                 for(i=0;i<4;i++)
 172                 {
 173                         pa.setCornerSmoothFlag(i, pi.getCornerSmoothFlag(i));
 174                 }
 175
 176                 // Copy order of the patch
 177                 pa.OrderS= pi.OrderS;
 178                 pa.OrderT= pi.OrderT;
 179
 180                 // Build the patch.
 181                 for(i=0;i<4;i++)
 182                         pa.Vertices[i].pack(p.Vertices[i], PatchBias, PatchScale);
 183                 for(i=0;i<8;i++)
 184                         pa.Tangents[i].pack(p.Tangents[i], PatchBias, PatchScale);
 185                 for(i=0;i<4;i++)
 186                         pa.Interiors[i].pack(p.Interiors[i], PatchBias, PatchScale);
 187                 pa.Tiles= pi.Tiles;
 188                 pa.TileColors= pi.TileColors;
 189                 /* Copy TileLightInfluences. It is possible that pi.TileLightInfluences.size()!= 0
 190                         and pi.TileLightInfluences.size()!= (uint)(pi.OrderS/2+1)*(pi.OrderT/2+1)
 191                         Because of a preceding bug where pa.OrderS and pa.OrderT were not initialized before the
 192                         pa.resetTileLightInfluences();
 193                 */
 194                 if( pi.TileLightInfluences.size()!= (uint)(pi.OrderS/2+1)*(pi.OrderT/2+1) )
 195                 {
 196                         pa.resetTileLightInfluences();
 197                 }
 198                 else
 199                 {
 200                         pa.TileLightInfluences= pi.TileLightInfluences;
 201                 }
 202
 203                 // Number of lumels in this patch
 204                 uint lumelCount=(pi.OrderS*NL_LUMEL_BY_TILE)*(pi.OrderT*NL_LUMEL_BY_TILE);
 205
 206                 // Lumel empty ?
 207                 if (pi.Lumels.size ()==lumelCount)
 208                 {
 209                         // Pack the lumel map
 210                         pa.packShadowMap (&pi.Lumels[0]);
 211                 }
 212                 else
 213                 {
 214                         // Reset lightmap
 215                         pa.resetCompressedLumels ();
 216                 }
 217
 218                 nlassert(pa.Tiles.size()== (uint)pi.OrderS*pi.OrderT);
 219                 nlassert(pa.TileColors.size()== (uint)(pi.OrderS+1)*(pi.OrderT+1));
 220
 221                 // Build the patchConnect.
 222                 pc.ErrorSize= pi.ErrorSize;
 223                 for(i=0;i<4;i++)
 224                 {
 225                         pc.BaseVertices[i]= pi.BaseVertices[i];
 226                         maxVertex= max((sint)pc.BaseVertices[i], maxVertex);
 227                 }
 228                 for(i=0;i<4;i++)
 229                         pc.BindEdges[i]= pi.BindEdges[i];
 230         }
 231
 232         NumVertices= maxVertex+1;
 233         NumVertices= max((uint32)NumVertices, numVertices);
 234
 235         // Init the Clip Arrays
 236         _PatchRenderClipped.resize((uint)Patchs.size());
 237         _PatchOldRenderClipped.resize((uint)Patchs.size());
 238         _PatchRenderClipped.setAll();
 239         _PatchOldRenderClipped.setAll();
 240
 241         // Copy PointLights.
 242         //=========================
 243         // build array, lights are sorted
 244         std::vector<uint>       plRemap;
 245         _PointLightArray.build(zoneInfo.PointLights, plRemap);
 246         // Check TileLightInfluences integrity, and remap PointLight Indices.
 247         for(j=0;j<(sint)patchs.size();j++)
 248         {
 249                 CPatch                          &pa= Patchs[j];
 250                 for(uint k= 0; k<pa.TileLightInfluences.size(); k++)
 251                 {
 252                         CTileLightInfluence             &tli= pa.TileLightInfluences[k];
 253                         for(uint l=0; l<CTileLightInfluence::NumLightPerCorner; l++)
 254                         {
 255                                 // If NULL light, break and continue to next TileLightInfluence.
 256                                 if(tli.Light[l]== 0xFF)
 257                                         break;
 258                                 else
 259                                 {
 260                                         // Check good index.
 261                                         nlassert(tli.Light[l] < _PointLightArray.getPointLights().size());
 262                                         // Remap index, because of light sorting.
 263                                         tli.Light[l]= plRemap[tli.Light[l]];
 264                                 }
 265
 266                         }
 267                 }
 268         }
 269 }
 270
 271 // ***************************************************************************
 272 void                    CZone::retrieve(std::vector<CPatchInfo> &patchs, std::vector<CBorderVertex> &borderVertices)
 273 {
 274         CZoneInfo       zinfo;
 275
 276         retrieve(zinfo);
 277
 278         patchs= zinfo.Patchs;
 279         borderVertices= zinfo.BorderVertices;
 280 }
 281
 282 // ***************************************************************************
 283 void                    CZone::retrieve(CZoneInfo &zoneInfo)
 284 {
 285         sint i,j;
 286
 287         // Ref on input.
 288         std::vector<CPatchInfo> &patchs= zoneInfo.Patchs;
 289         std::vector<CBorderVertex> &borderVertices= zoneInfo.BorderVertices;
 290         // Copy zoneId.
 291         zoneInfo.ZoneId= getZoneId();
 292
 293
 294         // uncompress Patchs.
 295         //=========================
 296         patchs.resize(Patchs.size());
 297         for(j=0;j<(sint)patchs.size();j++)
 298         {
 299                 CPatchInfo                      &pi= patchs[j];
 300                 CBezierPatch            &p= pi.Patch;
 301                 CPatch                          &pa= Patchs[j];
 302                 CPatchConnect           &pc= PatchConnects[j];
 303
 304
 305                 // Smoothing flags
 306                 pi.Flags= (pa.Flags&NL_PATCH_SMOOTH_FLAG_MASK)>>NL_PATCH_SMOOTH_FLAG_SHIFT;
 307
 308
 309                 // Noise Data
 310                 // copy noise rotation.
 311                 pi.NoiseRotation= pa.NoiseRotation;
 312                 // copy all noise smoothing info.
 313                 for(i=0;i<4;i++)
 314                 {
 315                         pi.setCornerSmoothFlag(i, pa.getCornerSmoothFlag(i));
 316                 }
 317
 318
 319                 // re-Build the uncompressed bezier patch.
 320                 for(i=0;i<4;i++)
 321                         pa.Vertices[i].unpack(p.Vertices[i], PatchBias, PatchScale);
 322                 for(i=0;i<8;i++)
 323                         pa.Tangents[i].unpack(p.Tangents[i], PatchBias, PatchScale);
 324                 for(i=0;i<4;i++)
 325                         pa.Interiors[i].unpack(p.Interiors[i], PatchBias, PatchScale);
 326                 pi.Tiles= pa.Tiles;
 327                 pi.TileColors= pa.TileColors;
 328                 pi.TileLightInfluences= pa.TileLightInfluences;
 329                 pi.Lumels.resize ((pa.OrderS*4)*(pa.OrderT*4));
 330                 pi.Flags=(pa.Flags&NL_PATCH_SMOOTH_FLAG_MASK)>>NL_PATCH_SMOOTH_FLAG_SHIFT;
 331
 332                 // Unpack the lumel map
 333                 pa.unpackShadowMap (&pi.Lumels[0]);
 334
 335                 // from the patchConnect.
 336                 pi.OrderS= pa.OrderS;
 337                 pi.OrderT= pa.OrderT;
 338                 pi.ErrorSize= pc.ErrorSize;
 339                 for(i=0;i<4;i++)
 340                 {
 341                         pi.BaseVertices[i]= pc.BaseVertices[i];
 342                 }
 343                 for(i=0;i<4;i++)
 344                         pi.BindEdges[i]= pc.BindEdges[i];
 345         }
 346
 347         // retrieve bordervertices.
 348         //=========================
 349         borderVertices= BorderVertices;
 350
 351         // retrieve PointLights.
 352         //=========================
 353         zoneInfo.PointLights= _PointLightArray.getPointLights();
 354
 355 }
 356
 357
 358 // ***************************************************************************
 359 void                    CZone::build(const CZone &zone)
 360 {
 361         nlassert(!Compiled);
 362
 363         ZoneId= zone.ZoneId;
 364         BorderVertices= zone.BorderVertices;
 365
 366         // Compute the bbox and the bias/scale.
 367         //=====================================
 368         ZoneBB= zone.ZoneBB;
 369         PatchScale= zone.PatchScale;
 370         PatchBias= zone.PatchBias;
 371
 372
 373         // Compute/compress Patchs.
 374         //=========================
 375         Patchs= zone.Patchs;
 376         PatchConnects= zone.PatchConnects;
 377
 378         // Init the Clip Arrays
 379         _PatchRenderClipped.resize((uint)Patchs.size());
 380         _PatchOldRenderClipped.resize((uint)Patchs.size());
 381         _PatchRenderClipped.setAll();
 382         _PatchOldRenderClipped.setAll();
 383
 384
 385         // copy pointLights.
 386         //=========================
 387         _PointLightArray= zone._PointLightArray;
 388
 389
 390         NumVertices= zone.NumVertices;
 391 }
 392
 393
 394
 395 // ***************************************************************************
 396 void                    CBorderVertex::serial(NLMISC::IStream &f)
 397 {
 398         /* ***********************************************
 399          *      WARNING: This Class/Method must be thread-safe (ctor/dtor/serial): no static access for instance
 400          *      It can be loaded/called through CAsyncFileManager for instance
 401          * ***********************************************/
 402         (void)f.serialVersion(0);
 403
 404         f.xmlSerial (CurrentVertex, "CURRENT_VERTEX");
 405         f.xmlSerial (NeighborZoneId, "NEIGHTBOR_ZONE_ID");
 406         f.xmlSerial (NeighborVertex, "NEIGHTBOR_VERTEX");
 407 }
 408 void                    CZone::CPatchConnect::serial(NLMISC::IStream &f)
 409 {
 410         /* ***********************************************
 411          *      WARNING: This Class/Method must be thread-safe (ctor/dtor/serial): no static access for instance
 412          *      It can be loaded/called through CAsyncFileManager for instance
 413          * ***********************************************/
 414         uint    ver= f.serialVersion(1);
 415
 416         if (ver<1)
 417                 f.serial(OldOrderS, OldOrderT, ErrorSize);
 418         else
 419                 f.serial(ErrorSize);
 420         f.xmlSerial (BaseVertices[0], BaseVertices[1], BaseVertices[2], BaseVertices[3], "BASE_VERTICES");
 421         f.xmlSerial (BindEdges[0], BindEdges[1], BindEdges[2], BindEdges[3], "BIND_EDGES");
 422 }
 423 void                    CPatchInfo::CBindInfo::serial(NLMISC::IStream &f)
 424 {
 425         /* ***********************************************
 426          *      WARNING: This Class/Method must be thread-safe (ctor/dtor/serial): no static access for instance
 427          *      It can be loaded/called through CAsyncFileManager for instance
 428          * ***********************************************/
 429         (void)f.serialVersion(0);
 430         f.xmlSerial(NPatchs, "NPATCH");
 431         nlassert ( (NPatchs==0) | (NPatchs==1) | (NPatchs==2) | (NPatchs==4) | (NPatchs==5) );
 432         f.xmlSerial (ZoneId, "ZONE_ID");
 433         f.xmlSerial (Next[0], Next[1], Next[2], Next[3], "NEXT_PATCH");
 434         f.xmlSerial (Edge[0], Edge[1], Edge[2], Edge[3], "NEXT_EDGE");
 435 }
 436
 437 // ***************************************************************************
 438 void                    CZone::serial(NLMISC::IStream &f)
 439 {
 440         /* ***********************************************
 441          *      WARNING: This Class/Method must be thread-safe (ctor/dtor/serial): no static access for instance
 442          *      It can be loaded/called through CAsyncFileManager for instance
 443          * ***********************************************/
 444         /*
 445         Version 4:
 446                 - PointLights
 447         Version 3:
 448                 - Lumels compression version 2.
 449         Version 2:
 450                 - Lumels.
 451         Version 1:
 452                 - Tile color.
 453         Version 0:
 454                 - base verison.
 455         */
 456         uint    ver= f.serialVersion(4);
 457
 458         // No more compatibility before version 3
 459         if (ver<3)
 460         {
 461                 throw EOlderStream(f);
 462         }
 463
 464         f.serialCheck(NELID("ENOZ"));
 465
 466         f.xmlSerial (ZoneId, "ZONE_ID");
 467         f.xmlSerial (ZoneBB, "BB");
 468         f.xmlSerial (PatchBias, "PATCH_BIAS");
 469         f.xmlSerial (PatchScale, "PATCH_SCALE");
 470         f.xmlSerial (NumVertices, "NUM_VERTICES");
 471
 472         f.xmlPush ("BORDER_VERTICES");
 473         f.serialCont(BorderVertices);
 474         f.xmlPop ();
 475
 476         f.xmlPush ("PATCHES");
 477         f.serialCont(Patchs);
 478         f.xmlPop ();
 479
 480         f.xmlPush ("PATCH_CONNECTS");
 481         f.serialCont(PatchConnects);
 482         f.xmlPop ();
 483
 484         if (ver>=4)
 485         {
 486                 f.xmlPush ("POINT_LIGHTS");
 487                 f.serial(_PointLightArray);
 488                 f.xmlPop ();
 489         }
 490
 491         // If read, must create and init Patch Clipped state to true (clipped even if not compiled)
 492         if(f.isReading())
 493         {
 494                 _PatchRenderClipped.resize((uint)Patchs.size());
 495                 _PatchOldRenderClipped.resize((uint)Patchs.size());
 496                 _PatchRenderClipped.setAll();
 497                 _PatchOldRenderClipped.setAll();
 498         }
 499
 500         // If read and version 0, must init default TileColors of patchs.
 501         //===============================================================
 502         // if(f.isReading() && ver<2) ...
 503         // Deprecated, because ver<3 not supported
 504 }
 505
 506
 507
 508 // ***************************************************************************
 509 void                    CZone::compile(CLandscape *landscape, TZoneMap &loadedZones)
 510 {
 511         sint    i,j;
 512         TZoneMap                neighborZones;
 513
 514         //nlinfo("Compile Zone: %d \n", (sint32)getZoneId());
 515
 516         // Can't compile if compiled.
 517         nlassert(!Compiled);
 518         Landscape= landscape;
 519
 520         // Attach this to loadedZones.
 521         //============================
 522         nlassert(loadedZones.find(ZoneId)==loadedZones.end());
 523         loadedZones[ZoneId]= this;
 524
 525         // Create/link the base vertices according to present neigbor zones.
 526         //============================
 527         BaseVertices.clear();
 528         BaseVertices.resize(NumVertices);
 529         // First try to link vertices to other.
 530         for(i=0;i<(sint)BorderVertices.size();i++)
 531         {
 532                 sint    cur= BorderVertices[i].CurrentVertex;
 533                 sint    vertto= BorderVertices[i].NeighborVertex;
 534                 sint    zoneto= BorderVertices[i].NeighborZoneId;
 535                 nlassert(cur<NumVertices);
 536
 537                 if(loadedZones.find(zoneto)!=loadedZones.end())
 538                 {
 539                         CZone   *zone;
 540                         zone= (*loadedZones.find(zoneto)).second;
 541                         nlassert(zone!=this);
 542                         // insert the zone in the neigborood (if not done...).
 543                         neighborZones[zoneto]= zone;
 544                         // Doesn't matter if BaseVertices is already linked to another zone...
 545                         // This should be the same pointer in this case...
 546                         BaseVertices[cur]=  zone->getBaseVertex(vertto);
 547                 }
 548         }
 549         // Else, create unbounded vertices.
 550         for(i=0;i<(sint)BaseVertices.size();i++)
 551         {
 552                 if(BaseVertices[i]==NULL)
 553                 {
 554                         BaseVertices[i]=  new CTessBaseVertex;
 555                 }
 556         }
 557
 558
 559         // compile() the patchs.
 560         //======================
 561         for(j=0;j<(sint)Patchs.size();j++)
 562         {
 563                 CPatch                          &pa= Patchs[j];
 564                 CPatchConnect           &pc= PatchConnects[j];
 565                 CTessVertex                     *baseVertices[4];
 566
 567                 baseVertices[0]= &(BaseVertices[pc.BaseVertices[0]]->Vert);
 568                 baseVertices[1]= &(BaseVertices[pc.BaseVertices[1]]->Vert);
 569                 baseVertices[2]= &(BaseVertices[pc.BaseVertices[2]]->Vert);
 570                 baseVertices[3]= &(BaseVertices[pc.BaseVertices[3]]->Vert);
 571                 pa.compile(this, j, pa.OrderS, pa.OrderT, baseVertices, pc.ErrorSize);
 572         };
 573
 574         // compile() the Clip information for the patchs.
 575         //======================
 576         _PatchBSpheres.resize(Patchs.size());
 577         for(j=0;j<(sint)Patchs.size();j++)
 578         {
 579                 CPatch                          &pa= Patchs[j];
 580
 581                 // Buil the BSPhere of the patch.
 582                 CAABBox bb= pa.buildBBox();
 583                 _PatchBSpheres[j].Center= bb.getCenter();
 584                 _PatchBSpheres[j].Radius= bb.getRadius();
 585         }
 586
 587         // bind() the patchs. (after all compiled).
 588         //===================
 589         for(j=0;j<(sint)Patchs.size();j++)
 590         {
 591                 CPatch                          &pa= Patchs[j];
 592                 CPatchConnect           &pc= PatchConnects[j];
 593
 594                 // bind the patch. This is the original bind, not a rebind.
 595                 bindPatch(loadedZones, pa, pc, false);
 596         }
 597
 598
 599         // rebindBorder() on neighbor zones.
 600         //==================================
 601         ItZoneMap               zoneIt;
 602         // Traverse the neighborood.
 603         for(zoneIt= neighborZones.begin(); zoneIt!=neighborZones.end(); zoneIt++)
 604         {
 605                 (*zoneIt).second->rebindBorder(loadedZones);
 606         }
 607
 608         // End!!
 609         Compiled= true;
 610 }
 611
 612 // ***************************************************************************
 613 void                    CZone::release(TZoneMap &loadedZones)
 614 {
 615         sint    i,j;
 616
 617         if(!Compiled)
 618                 return;
 619
 620         // detach this zone to loadedZones.
 621         //=================================
 622         nlassert(loadedZones.find(ZoneId)!=loadedZones.end());
 623         loadedZones.erase(ZoneId);
 624         // It doesn't server to unbindPatch(), since patch is not binded to neigbors.
 625
 626
 627         // unbind() the patchs.
 628         //=====================
 629         for(j=0;j<(sint)Patchs.size();j++)
 630         {
 631                 CPatch                          &pa= Patchs[j];
 632                 unbindPatch(pa);
 633         }
 634
 635
 636         // rebindBorder() on neighbor zones.
 637         //==================================
 638         // Build the nieghborood.
 639         TZoneMap                neighborZones;
 640         for(i=0;i<(sint)BorderVertices.size();i++)
 641         {
 642                 sint    cur= BorderVertices[i].CurrentVertex;
 643                 sint    zoneto= BorderVertices[i].NeighborZoneId;
 644                 nlassert(cur<NumVertices);
 645
 646                 if(loadedZones.find(zoneto)!=loadedZones.end())
 647                 {
 648                         CZone   *zone;
 649                         zone= (*loadedZones.find(zoneto)).second;
 650                         nlassert(zone!=this);
 651                         // insert the zone in the neigborood (if not done...).
 652                         neighborZones[zoneto]= zone;
 653                 }
 654         }
 655         // rebind borders.
 656         ItZoneMap               zoneIt;
 657         // Traverse the neighborood.
 658         for(zoneIt= neighborZones.begin(); zoneIt!=neighborZones.end(); zoneIt++)
 659         {
 660                 // Since
 661                 (*zoneIt).second->rebindBorder(loadedZones);
 662         }
 663
 664
 665         // release() the patchs.
 666         //======================
 667         // unbind() need compiled neigbor patchs, so do the release after all unbind (so after rebindBorder() too...).
 668         for(j=0;j<(sint)Patchs.size();j++)
 669         {
 670                 CPatch                          &pa= Patchs[j];
 671                 pa.release();
 672         }
 673
 674
 675         // destroy/unlink the base vertices (internal..), according to present neigbor zones.
 676         //=================================
 677         // Just release the smartptrs (easy!!). Do it after patchs released...
 678         BaseVertices.clear();
 679
 680
 681         // End!!
 682         Compiled= false;
 683         Landscape= NULL;
 684         ClipResult= ClipOut;
 685 }
 686
 687
 688 // ***************************************************************************
 689 // ***************************************************************************
 690 // Private part.
 691 // ***************************************************************************
 692 // ***************************************************************************
 693
 694
 695 // ***************************************************************************
 696 void                    CZone::rebindBorder(TZoneMap &loadedZones)
 697 {
 698         sint    j;
 699
 700         // rebind patchs which are on border.
 701         for(j=0;j<(sint)Patchs.size();j++)
 702         {
 703                 CPatch                          &pa= Patchs[j];
 704                 CPatchConnect           &pc= PatchConnects[j];
 705
 706                 if(patchOnBorder(pc))
 707                 {
 708                         // rebind the patch. This is a rebind.
 709                         bindPatch(loadedZones, pa, pc, true);
 710                 }
 711         }
 712 }
 713
 714 // ***************************************************************************
 715 CPatch          *CZone::getZonePatch(TZoneMap &loadedZones, sint zoneId, sint patch)
 716 {
 717 #ifdef NL3D_DEBUG_DONT_BIND_PATCH
 718         return NULL;
 719 #endif
 720         if(loadedZones.find(zoneId)==loadedZones.end())
 721                 return NULL;
 722         else
 723                 return (loadedZones[zoneId])->getPatch(patch);
 724 }
 725
 726
 727 // ***************************************************************************
 728 void            CZone::buildBindInfo(uint patchId, uint edge, CZone *neighborZone, CPatch::CBindInfo    &paBind)
 729 {
 730         nlassert(patchId < Patchs.size());
 731         nlassert(neighborZone);
 732
 733         CPatchConnect   &pc= PatchConnects[patchId];
 734
 735
 736         // Get the bind info of this patch to his neighbor on "edge".
 737         CPatchInfo::CBindInfo   &pcBind= pc.BindEdges[edge];
 738         nlassert(pcBind.NPatchs==0 || pcBind.NPatchs==1 || pcBind.NPatchs==2 || pcBind.NPatchs==4 || pcBind.NPatchs==5);
 739
 740
 741         // copy zone ptr.
 742         paBind.Zone= neighborZone;
 743
 744
 745         // Special case of a small patch connected to a bigger.
 746         if(pcBind.NPatchs==5)
 747         {
 748                 paBind.NPatchs= 1;
 749                 paBind.Next[0]= neighborZone->getPatch(pcBind.Next[0]);
 750                 paBind.Edge[0]= pcBind.Edge[0];
 751
 752                 // Get the twin bindInfo of pcBind.
 753                 const CPatchInfo::CBindInfo     &pcBindNeighbor=
 754                         neighborZone->getPatchConnect(pcBind.Next[0])->BindEdges[pcBind.Edge[0]];
 755                 // must have a multiple bind.
 756                 nlassert(pcBindNeighbor.NPatchs == 2 || pcBindNeighbor.NPatchs == 4);
 757
 758                 // number of bind is stored on the twin bindInfo.
 759                 paBind.MultipleBindNum= pcBindNeighbor.NPatchs;
 760
 761                 // Search our patchId on neighbor;
 762                 paBind.MultipleBindId= 255;
 763                 for(sint i=0; i<paBind.MultipleBindNum; i++)
 764                 {
 765                         if(pcBindNeighbor.Next[i]==patchId)
 766                                 paBind.MultipleBindId= i;
 767                 }
 768                 nlassert(paBind.MultipleBindId!= 255);
 769         }
 770         else
 771         {
 772                 paBind.MultipleBindNum= 0;
 773                 paBind.NPatchs= pcBind.NPatchs;
 774                 for(sint i=0;i<paBind.NPatchs; i++)
 775                 {
 776                         paBind.Next[i]= neighborZone->getPatch(pcBind.Next[i]);
 777                         paBind.Edge[i]= pcBind.Edge[i];
 778                 }
 779         }
 780
 781
 782 }
 783
 784
 785 // ***************************************************************************
 786 void            CZone::bindPatch(TZoneMap &loadedZones, CPatch &pa, CPatchConnect &pc, bool rebind)
 787 {
 788         CPatch::CBindInfo       edges[4];
 789
 790         // Fill all edges.
 791         for(sint i=0;i<4;i++)
 792         {
 793                 CPatchInfo::CBindInfo   &pcBind= pc.BindEdges[i];
 794                 CPatch::CBindInfo               &paBind= edges[i];
 795
 796                 nlassert(pcBind.NPatchs==0 || pcBind.NPatchs==1 || pcBind.NPatchs==2 || pcBind.NPatchs==4 || pcBind.NPatchs==5);
 797                 paBind.NPatchs= pcBind.NPatchs;
 798
 799
 800                 // Find the zone.
 801                 TZoneMap::iterator      itZoneMap;
 802                 // If no neighbor, or if zone neighbor not loaded.
 803                 if( paBind.NPatchs==0 || (itZoneMap=loadedZones.find(pcBind.ZoneId)) == loadedZones.end() )
 804                         paBind.Zone= NULL;
 805                 else
 806                         paBind.Zone= itZoneMap->second;
 807
 808
 809                 // Special case of a small patch connected to a bigger.
 810                 if(paBind.NPatchs==5)
 811                 {
 812                         paBind.Edge[0]= pcBind.Edge[0];
 813                         paBind.Next[0]= CZone::getZonePatch(loadedZones, pcBind.ZoneId, pcBind.Next[0]);
 814                         // If not loaded, don't bind to this edge.
 815                         if(!paBind.Next[0])
 816                                 paBind.NPatchs=0;
 817                         else
 818                         {
 819                                 // pa.bind() will do the job.
 820                                 // Leave it flagged with NPatchs==5.
 821                                 continue;
 822                         }
 823                 }
 824
 825
 826                 // Bind 1/1 and 1/2,1/4
 827                 if(paBind.NPatchs>=1)
 828                 {
 829                         paBind.Edge[0]= pcBind.Edge[0];
 830                         paBind.Next[0]= CZone::getZonePatch(loadedZones, pcBind.ZoneId, pcBind.Next[0]);
 831                         // If not loaded, don't bind to this edge.
 832                         if(!paBind.Next[0])
 833                                 paBind.NPatchs=0;
 834                 }
 835                 if(paBind.NPatchs>=2)
 836                 {
 837                         paBind.Edge[1]= pcBind.Edge[1];
 838                         paBind.Next[1]= CZone::getZonePatch(loadedZones, pcBind.ZoneId, pcBind.Next[1]);
 839                         // If not loaded, don't bind to this edge.
 840                         if(!paBind.Next[1])
 841                                 paBind.NPatchs=0;
 842                 }
 843                 if(paBind.NPatchs>=4)
 844                 {
 845                         paBind.Edge[2]= pcBind.Edge[2];
 846                         paBind.Edge[3]= pcBind.Edge[3];
 847                         paBind.Next[2]= CZone::getZonePatch(loadedZones, pcBind.ZoneId, pcBind.Next[2]);
 848                         paBind.Next[3]= CZone::getZonePatch(loadedZones, pcBind.ZoneId, pcBind.Next[3]);
 849                         // If not loaded, don't bind to this edge.
 850                         if(!paBind.Next[2] || !paBind.Next[3])
 851                                 paBind.NPatchs=0;
 852                 }
 853         }
 854
 855         // First, unbind.
 856         pa.unbind();
 857
 858         // Then bind.
 859         pa.bind(edges, rebind);
 860 }
 861
 862
 863 // ***************************************************************************
 864 void            CZone::unbindPatch(CPatch &pa)
 865 {
 866         /*
 867                 Remind: the old version with CPatch::unbindFrom*() doesn't work because of CZone::release(). This function
 868                 first erase the zone from loadedZones...
 869                 Not matter here. We use CPatch::unbind() which should do all the good job correctly (unbind pa from ohters
 870                 , and unbind others from pa at same time).
 871         */
 872
 873         pa.unbind();
 874 }
 875
 876
 877 // ***************************************************************************
 878 bool                    CZone::patchOnBorder(const CPatchConnect &pc) const
 879 {
 880         // If only one of neighbor patch is not of this zone, we are on a border.
 881
 882         // Test all edges.
 883         for(sint i=0;i<4;i++)
 884         {
 885                 const CPatchInfo::CBindInfo     &pcBind= pc.BindEdges[i];
 886
 887                 nlassert(pcBind.NPatchs==0 || pcBind.NPatchs==1 || pcBind.NPatchs==2 || pcBind.NPatchs==4 || pcBind.NPatchs==5);
 888                 if(pcBind.NPatchs>=1)
 889                 {
 890                         if(pcBind.ZoneId != ZoneId)
 891                                 return true;
 892                 }
 893         }
 894
 895         return false;
 896 }
 897
 898
 899 // ***************************************************************************
 900 // ***************************************************************************
 901 // Render part.
 902 // ***************************************************************************
 903 // ***************************************************************************
 904
 905
 906 // ***************************************************************************
 907 const CBSphere  &CZone::getPatchBSphere(uint patch) const
 908 {
 909         static  CBSphere        dummySphere;
 910         if(patch<_PatchBSpheres.size())
 911                 return _PatchBSpheres[patch];
 912         else
 913                 return dummySphere;
 914 }
 915
 916
 917 // ***************************************************************************
 918 void                    CZone::clip(const std::vector<CPlane>   &pyramid)
 919 {
 920         H_AUTO( NLMISC_ClipZone );
 921
 922         nlassert(Compiled);
 923
 924         // bkup old ClipResult. NB: by default, it is ClipOut (no VB created).
 925         sint    oldClipResult= ClipResult;
 926
 927         // Pyramid with only the planes that clip the zone
 928         static std::vector<CPlane>              patchPyramid(10);
 929         static std::vector<uint>                patchPyramidIndex(10);
 930         patchPyramidIndex.clear();
 931
 932         // Compute ClipResult.
 933         //-------------------
 934         ClipResult= ClipIn;
 935         for(sint i=0;i<(sint)pyramid.size();i++)
 936         {
 937                 // If entirely out.
 938                 if(!ZoneBB.clipBack(pyramid[i]))
 939                 {
 940                         ClipResult= ClipOut;
 941                         // If out of only one plane, out of all.
 942                         break;
 943                 }
 944                 // If partially IN (ie not entirely out, and not entirely IN)
 945                 else if(ZoneBB.clipFront(pyramid[i]))
 946                 {
 947                         // Force ClipResult to be ClipSide, and not ClipIn.
 948                         ClipResult=ClipSide;
 949                         // Append the plane index to list to test
 950                         patchPyramidIndex.push_back(i);
 951                 }
 952         }
 953
 954
 955         // Easy Clip  :)
 956         if(Patchs.empty())
 957         {
 958                 ClipResult= ClipOut;
 959                 // don't need to go below...
 960                 return;
 961         }
 962
 963
 964         // Clip By Patch Pass.
 965         //--------------------
 966         if(ClipResult==ClipOut)
 967         {
 968                 H_AUTO( NLMISC_ClipZone_Out );
 969
 970                 // Set All RenderClip flags to true.
 971                 _PatchRenderClipped.setAll();
 972         }
 973         else if(ClipResult==ClipIn)
 974         {
 975                 H_AUTO( NLMISC_ClipZone_In );
 976
 977                 // Set All RenderClip flags to false.
 978                 _PatchRenderClipped.clearAll();
 979         }
 980         else
 981         {
 982                 H_AUTO( NLMISC_ClipZone_Side );
 983
 984                 // Copy only the pyramid planes of interest
 985                 patchPyramid.resize(patchPyramidIndex.size());
 986                 uint i;
 987                 for(i=0;i<patchPyramidIndex.size();i++)
 988                 {
 989                         patchPyramid[i]= pyramid[patchPyramidIndex[i]];
 990                 }
 991
 992                 // clip all patchs with the simplified pyramid
 993                 clipPatchs(patchPyramid);
 994         }
 995
 996
 997         // delete / reallocate / fill VBuffers.
 998         //-------------------
 999         // If there is a change in the Clip of the zone, or if patchs may have change (ie ClipSide is undetermined).
1000         if(oldClipResult!=ClipResult || oldClipResult==ClipSide)
1001         {
1002                 // get BitSet as Raw Array of uint32
1003                 uint32  *oldRenderClip= const_cast<uint32*>(&_PatchOldRenderClipped.getVector()[0]);
1004                 const   uint32  *newRenderClip= &_PatchRenderClipped.getVector()[0];
1005                 uint    numPatchs= (uint)Patchs.size();
1006                 // Then, we must test by patch.
1007                 for(uint i=0;i<numPatchs;oldRenderClip++, newRenderClip++)
1008                 {
1009                         uint32  oldWord= *oldRenderClip;
1010                         uint32  newWord= *newRenderClip;
1011                         // process at max 32 patch
1012                         uint    maxNumBits= min((numPatchs-i), 32U);
1013                         uint32  mask= 1;
1014                         for(;maxNumBits>0;maxNumBits--, mask<<=1, i++)
1015                         {
1016                                 // same as: if(_PatchOldRenderClipped[i] != _PatchRenderClipped[i])
1017                                 if( (oldWord^newWord)&mask )
1018                                 {
1019                                         // set the flag.
1020                                         *oldRenderClip&= ~mask;
1021                                         *oldRenderClip|= newWord&mask;
1022                                         // update clip patch
1023                                         Patchs[i].updateClipPatchVB( (newWord&mask)!=0 );
1024                                 }
1025                         }
1026                 }
1027
1028         }
1029
1030 }
1031
1032
1033 // ***************************************************************************
1034 void                    CZone::clipPatchs(const std::vector<CPlane>     &pyramid)
1035 {
1036         // Init all to Not clipped
1037         _PatchRenderClipped.clearAll();
1038
1039         for(uint j=0;j<_PatchBSpheres.size();j++)
1040         {
1041                 CBSphere        &bSphere= _PatchBSpheres[j];
1042                 for(sint i=0;i<(sint)pyramid.size();i++)
1043                 {
1044                         // If entirely out.
1045                         if(!bSphere.clipBack(pyramid[i]))
1046                         {
1047                                 _PatchRenderClipped.set(j, true);
1048                                 break;
1049                         }
1050                 }
1051         }
1052 }
1053
1054
1055 // ***************************************************************************
1056 // DebugYoyo.
1057 // Code for Debug test Only.. Do not erase it, may be used later :)
1058 /*
1059 static  void    cleanTess(CTessFace *face)
1060 {
1061         if(!face->isLeaf())
1062         {
1063                 cleanTess(face->SonLeft);
1064                 cleanTess(face->SonRight);
1065         }
1066         // If has father, clean it.
1067         if(face->Father)
1068         {
1069                 CTessFace       *face1=face->Father;
1070                 CTessFace       *face2=face->Father->FBase;
1071                 face1->FLeft= face1->SonLeft->FBase;
1072                 face1->FRight= face1->SonRight->FBase;
1073                 if(face2!=NULL)
1074                 {
1075                         face2->FLeft= face2->SonLeft->FBase;
1076                         face2->FRight= face2->SonRight->FBase;
1077                 }
1078         }
1079 }
1080 static  void    testTess(CTessFace *face)
1081 {
1082         if(!face->isLeaf())
1083         {
1084                 testTess(face->SonLeft);
1085                 testTess(face->SonRight);
1086         }
1087         // Test validity.
1088         nlassert(!face->FBase || face->FBase->Patch!=(CPatch*)0xdddddddd);
1089         nlassert(!face->FLeft || face->FLeft->Patch!=(CPatch*)0xdddddddd);
1090         nlassert(!face->FRight || face->FRight->Patch!=(CPatch*)0xdddddddd);
1091 }
1092 static  void    checkTess()
1093 {
1094         // This test should be inserted at begin of CZone::refine().
1095         // And it needs hacking public/private.
1096         CPatch          *pPatch;
1097         sint            n;
1098         pPatch= &(*Patchs.begin());
1099         for(n=(sint)Patchs.size();n>0;n--, pPatch++)
1100         {
1101                 cleanTess(pPatch->Son0);
1102                 cleanTess(pPatch->Son1);
1103         }
1104         pPatch= &(*Patchs.begin());
1105         for(n=(sint)Patchs.size();n>0;n--, pPatch++)
1106         {
1107                 testTess(pPatch->Son0);
1108                 testTess(pPatch->Son1);
1109         }
1110 }
1111 */
1112
1113
1114 // ***************************************************************************
1115 void                    CZone::excludePatchFromRefineAll(uint patch, bool exclude)
1116 {
1117         nlassert(Compiled);
1118         nlassert(patch<Patchs.size());
1119
1120         if(patch>=Patchs.size())
1121                 return;
1122
1123         Patchs[patch].ExcludeFromRefineAll= exclude;
1124 }
1125
1126
1127 // ***************************************************************************
1128 void                    CZone::refineAll()
1129 {
1130         nlassert(Compiled);
1131
1132         if(Patchs.empty())
1133                 return;
1134
1135         // DO NOT do a forceNoRenderClip(), to avoid big allocation of Near/Far VB vertices in driver.
1136         // DO NOT modify ClipResult, to avoid big allocation of Near/Far VB vertices in driver.
1137
1138         // refine ALL patchs (even those which may be invisible).
1139         CPatch          *pPatch= &(*Patchs.begin());
1140         sint n;
1141         for(n=(sint)Patchs.size();n>0;n--, pPatch++)
1142         {
1143                 // For Pacs construction: may exclude some patch from refineAll (for speed improvement).
1144                 if(!pPatch->ExcludeFromRefineAll)
1145                         pPatch->refineAll();
1146         }
1147
1148 }
1149
1150
1151 // ***************************************************************************
1152 void                    CZone::averageTesselationVertices()
1153 {
1154         nlassert(Compiled);
1155
1156         if(Patchs.empty())
1157                 return;
1158
1159         // averageTesselationVertices of ALL patchs.
1160         CPatch          *pPatch= &(*Patchs.begin());
1161         for(sint n=(sint)Patchs.size();n>0;n--, pPatch++)
1162         {
1163                 pPatch->averageTesselationVertices();
1164         }
1165 }
1166
1167
1168 // ***************************************************************************
1169 void                    CZone::preRender()
1170 {
1171         nlassert(Compiled);
1172
1173         // Must be 2^X-1.
1174         static const    uint    updateFarRefineFreq= 15;
1175         // Take the renderDate here.
1176         uint            curDateMod= CLandscapeGlobals::CurrentRenderDate & updateFarRefineFreq;
1177
1178         // If no patchs, do nothing.
1179         if(Patchs.empty())
1180                 return;
1181
1182         /* If patchs invisible, must still update their Far Textures,
1183                 else, there may be slowdown when we turn the head.
1184         */
1185
1186
1187         // If all the zone is invisible.
1188         if(ClipResult==ClipOut)
1189         {
1190                 // No patchs are visible, but maybe update the far textures.
1191                 if( curDateMod==(ZoneId & updateFarRefineFreq) )
1192                 {
1193                         // updateTextureFarOnly for all patchs.
1194                         for(uint i=0;i<Patchs.size();i++)
1195                         {
1196                                 Patchs[i].updateTextureFarOnly(_PatchBSpheres[i]);
1197                         }
1198                 }
1199         }
1200         // else If some patchs only are visible.
1201         else if(ClipResult==ClipSide)
1202         {
1203                 // PreRender Pass, or updateTextureFarOnly(), according to _PatchRenderClipped state.
1204                 for(uint i=0;i<Patchs.size();i++)
1205                 {
1206                         // If the patch is visible
1207                         if(!_PatchRenderClipped[i])
1208                         {
1209                                 // Then preRender it.
1210                                 Patchs[i].preRender(_PatchBSpheres[i]);
1211                         }
1212                         else
1213                         {
1214                                 // else maybe updateFar it.
1215                                 // ZoneId+i for better repartition.
1216                                 if( curDateMod==((ZoneId+i) & updateFarRefineFreq) )
1217                                         Patchs[i].updateTextureFarOnly(_PatchBSpheres[i]);
1218                         }
1219                 }
1220         }
1221         else    // ClipResult==ClipIn
1222         {
1223                 // PreRender Pass for All
1224                 for(uint i=0;i<Patchs.size();i++)
1225                 {
1226                         Patchs[i].preRender(_PatchBSpheres[i]);
1227                 }
1228         }
1229
1230 }
1231
1232
1233 // ***************************************************************************
1234 void                    CZone::resetRenderFarAndDeleteVBFV()
1235 {
1236         for(uint i=0;i<Patchs.size();i++)
1237         {
1238                 // If patch is visible
1239                 if(!_PatchRenderClipped[i])
1240                 {
1241                         // release VertexBuffer, and FaceBuffer
1242                         Patchs[i].deleteVBAndFaceVector();
1243                         // Flag.
1244                         _PatchRenderClipped.set(i, true);
1245                 }
1246
1247                 Patchs[i].resetRenderFar();
1248         }
1249 }
1250
1251
1252 // ***************************************************************************
1253 void                    CZone::forceMergeAtTileLevel()
1254 {
1255         CPatch          *pPatch=0;
1256
1257         if (!Patchs.empty())
1258                 pPatch= &(*Patchs.begin());
1259
1260         for(sint n=(sint)Patchs.size();n>0;n--, pPatch++)
1261         {
1262                 pPatch->forceMergeAtTileLevel();
1263         }
1264 }
1265
1266
1267 // ***************************************************************************
1268 // ***************************************************************************
1269 // Misc part.
1270 // ***************************************************************************
1271 // ***************************************************************************
1272
1273
1274 // ***************************************************************************
1275 void                    CZone::changePatchTextureAndColor (sint numPatch, const std::vector<CTileElement> *tiles, const std::vector<CTileColor> *colors)
1276 {
1277         nlassert(numPatch>=0);
1278         nlassert(numPatch<getNumPatchs());
1279
1280
1281         // Update the patch texture.
1282         if (tiles)
1283         {
1284                 nlassert( Patchs[numPatch].Tiles.size() == tiles->size() );
1285                 Patchs[numPatch].Tiles = *tiles;
1286         }
1287
1288         // Update the patch colors.
1289         if (colors)
1290         {
1291                 nlassert( Patchs[numPatch].TileColors.size() == colors->size() );
1292                 Patchs[numPatch].TileColors = *colors;
1293         }
1294
1295         if (Compiled)
1296         {
1297                 // If the patch is visible, then we must LockBuffers, because new VertexVB may be created.
1298                 if(!_PatchRenderClipped[numPatch])
1299                         Landscape->updateGlobalsAndLockBuffers(CVector::Null);
1300
1301                 // Recompute UVs for new setup of Tiles.
1302                 Patchs[numPatch].deleteTileUvs();
1303                 Patchs[numPatch].recreateTileUvs();
1304
1305                 // unlockBuffers() if necessary.
1306                 if(!_PatchRenderClipped[numPatch])
1307                 {
1308                         Landscape->unlockBuffers();
1309                         // This patch is visible, and TileFaces have been deleted / added.
1310                         // So must update TessBlock.
1311                         Landscape->updateTessBlocksFaceVector();
1312                 }
1313         }
1314 }
1315
1316
1317 // ***************************************************************************
1318 void                    CZone::refreshTesselationGeometry(sint numPatch)
1319 {
1320         nlassert(numPatch>=0);
1321         nlassert(numPatch<getNumPatchs());
1322         nlassert(Compiled);
1323
1324         // At next render, we must re-fill the entire unclipped VB, so change are taken into account.
1325         Landscape->_RenderMustRefillVB= true;
1326
1327         Patchs[numPatch].refreshTesselationGeometry();
1328 }
1329
1330
1331 // ***************************************************************************
1332 const std::vector<CTileElement> &CZone::getPatchTexture(sint numPatch) const
1333 {
1334         nlassert(numPatch>=0);
1335         nlassert(numPatch<getNumPatchs());
1336
1337         // Update the patch texture.
1338         return Patchs[numPatch].Tiles;
1339 }
1340
1341
1342 // ***************************************************************************
1343 const std::vector<CTileColor> &CZone::getPatchColor(sint numPatch) const
1344 {
1345         nlassert(numPatch>=0);
1346         nlassert(numPatch<getNumPatchs());
1347
1348         // Update the patch texture.
1349         return Patchs[numPatch].TileColors;
1350 }
1351
1352 // ***************************************************************************
1353 void CZone::setTileColor(bool monochrome, float factor)
1354 {
1355         nlassert(factor >= 0.0f); // factor must not be negative as its a multiplier
1356
1357         if (monochrome)
1358         {
1359                 for (uint32 i = 0; i < Patchs.size(); ++i)
1360                 {
1361                         vector<CTileColor> &rTC = Patchs[i].TileColors;
1362                         for (uint32 j =  0; j < rTC.size(); ++j)
1363                         {
1364                                 float fR = (rTC[j].Color565 & 31) / 32.0f;
1365                                 float fG = ((rTC[j].Color565 >> 5) & 63) / 64.0f;
1366                                 float fB = ((rTC[j].Color565 >> 11) & 31) / 32.0f;
1367
1368                                 fR = 0.28f * fR + 0.59f * fG + 0.13f * fB;
1369
1370                                 nlassert(fR < 0.99f);
1371
1372                                 fR *= factor;
1373                                 if (fR > 0.99f) fR = 0.99f; // Avoid reaching 1
1374
1375                                 uint16 nR = (uint16)(fR * 32.0f);
1376                                 uint16 nG = (uint16)(fR * 64.0f);
1377                                 uint16 nB = (uint16)(fR * 32.0f);
1378
1379                                 rTC[j].Color565 = nR + (nG << 5) + (nB << 11);
1380                         }
1381                 }
1382         }
1383         else
1384         {
1385                 if (factor != 1.0f)
1386                 {
1387                         for (uint32 i = 0; i < Patchs.size(); ++i)
1388                         {
1389                                 vector<CTileColor> &rTC = Patchs[i].TileColors;
1390                                 for (uint32 j =  0; j < rTC.size(); ++j)
1391                                 {
1392                                         float fR = (rTC[j].Color565 & 31) / 32.0f;
1393                                         float fG = ((rTC[j].Color565 >> 5) & 63) / 64.0f;
1394                                         float fB = ((rTC[j].Color565 >> 11) & 31) / 32.0f;
1395
1396                                         fR *= factor;
1397                                         fG *= factor;
1398                                         fB *= factor;
1399
1400                                         if (fR > 0.99f) fR = 0.99f;
1401                                         if (fG > 0.99f) fG = 0.99f;
1402                                         if (fB > 0.99f) fB = 0.99f;
1403
1404                                         uint16 nR = (uint16)(fR * 32.0f);
1405                                         uint16 nG = (uint16)(fG * 64.0f);
1406                                         uint16 nB = (uint16)(fB * 32.0f);
1407
1408                                         rTC[j].Color565 = nR + (nG << 5) + (nB << 11);
1409                                 }
1410                         }
1411                 }
1412         }
1413 }
1414
1415 // ***************************************************************************
1416 void                    CZone::debugBinds(FILE *f)
1417 {
1418         fprintf(f, "*****************************\n");
1419         fprintf(f, "ZoneId: %d. NPatchs:%u\n", ZoneId, (uint)PatchConnects.size());
1420         sint i;
1421         for(i=0;i<(sint)PatchConnects.size();i++)
1422         {
1423                 CPatchConnect   &pc= PatchConnects[i];
1424                 fprintf(f, "patch%d:\n", i);
1425                 for(sint j=0;j<4;j++)
1426                 {
1427                         CPatchInfo::CBindInfo   &bd= pc.BindEdges[j];
1428                         fprintf(f, "    edge%d: Zone:%u. NPatchs:%u. ", j, (uint)bd.ZoneId, (uint)bd.NPatchs);
1429                         for(sint k=0;k<bd.NPatchs;k++)
1430                         {
1431                                 fprintf(f, "p%ue%u - ", (uint)bd.Next[k], (uint)bd.Edge[k]);
1432                         }
1433                         fprintf(f, "\n");
1434                 }
1435         }
1436
1437         fprintf(f,"Vertices :\n");
1438         for(i=0;i<(sint)BorderVertices.size();i++)
1439         {
1440                 fprintf(f,"current : %u -> (zone %u) vertex %u\n", (uint)BorderVertices[i].CurrentVertex,
1441                                                                                         (uint)BorderVertices[i].NeighborZoneId,
1442                                                                                         (uint)BorderVertices[i].NeighborVertex);
1443         }
1444 }
1445
1446
1447 // ***************************************************************************
1448 void                    CZone::applyHeightField(const CLandscape &landScape)
1449 {
1450         sint    i,j;
1451         vector<CBezierPatch>    patchs;
1452
1453         // no patch, do nothing.
1454         if(Patchs.empty())
1455                 return;
1456
1457         // 0. Unpack patchs to Bezier Patchs.
1458         //===================================
1459         patchs.resize(Patchs.size());
1460         for(j=0;j<(sint)patchs.size();j++)
1461         {
1462                 CBezierPatch            &p= patchs[j];
1463                 CPatch                          &pa= Patchs[j];
1464
1465                 // re-Build the uncompressed bezier patch.
1466                 for(i=0;i<4;i++)
1467                         pa.Vertices[i].unpack(p.Vertices[i], PatchBias, PatchScale);
1468                 for(i=0;i<8;i++)
1469                         pa.Tangents[i].unpack(p.Tangents[i], PatchBias, PatchScale);
1470                 for(i=0;i<4;i++)
1471                         pa.Interiors[i].unpack(p.Interiors[i], PatchBias, PatchScale);
1472         }
1473
1474         // 1. apply heightfield on bezier patchs.
1475         //===================================
1476         for(j=0;j<(sint)patchs.size();j++)
1477         {
1478                 CBezierPatch            &p= patchs[j];
1479
1480                 // apply delta.
1481                 for(i=0;i<4;i++)
1482                         p.Vertices[i]+= landScape.getHeightFieldDeltaZ(p.Vertices[i].x, p.Vertices[i].y);
1483                 for(i=0;i<8;i++)
1484                         p.Tangents[i]+= landScape.getHeightFieldDeltaZ(p.Tangents[i].x, p.Tangents[i].y);
1485                 for(i=0;i<4;i++)
1486                         p.Interiors[i]+= landScape.getHeightFieldDeltaZ(p.Interiors[i].x, p.Interiors[i].y);
1487         }
1488
1489
1490         // 2. Re-compute Patch Scale/Bias, and Zone BBox.
1491         //===================================
1492         CAABBox         bb;
1493         bb.setCenter(patchs[0].Vertices[0]);
1494         bb.setHalfSize(CVector::Null);
1495         for(j=0;j<(sint)patchs.size();j++)
1496         {
1497                 // extend bbox.
1498                 const CBezierPatch      &p= patchs[j];
1499                 for(i=0;i<4;i++)
1500                         bb.extend(p.Vertices[i]);
1501                 for(i=0;i<8;i++)
1502                         bb.extend(p.Tangents[i]);
1503                 for(i=0;i<4;i++)
1504                         bb.extend(p.Interiors[i]);
1505         }
1506         // Compute BBox, and Patch Scale Bias, according to Noise.
1507         computeBBScaleBias(bb);
1508
1509
1510         // 3. Re-pack patchs.
1511         //===================================
1512         for(j=0;j<(sint)patchs.size();j++)
1513         {
1514                 CBezierPatch            &p= patchs[j];
1515                 CPatch                          &pa= Patchs[j];
1516
1517                 // Build the packed patch.
1518                 for(i=0;i<4;i++)
1519                         pa.Vertices[i].pack(p.Vertices[i], PatchBias, PatchScale);
1520                 for(i=0;i<8;i++)
1521                         pa.Tangents[i].pack(p.Tangents[i], PatchBias, PatchScale);
1522                 for(i=0;i<4;i++)
1523                         pa.Interiors[i].pack(p.Interiors[i], PatchBias, PatchScale);
1524         }
1525 }
1526
1527 // ***************************************************************************
1528 void CZone::setupColorsFromTileFlags(const NLMISC::CRGBA colors[4])
1529 {
1530         for (uint k = 0; k < Patchs.size(); ++k)
1531         {
1532                 Patchs[k].setupColorsFromTileFlags(colors);
1533         }
1534 }
1535
1536
1537 // ***************************************************************************
1538 void CZone::copyTilesFlags(sint destPatchId, const CPatch *srcPatch)
1539 {
1540         CPatch *destPatch = getPatch(destPatchId);
1541
1542         destPatch->copyTileFlagsFromPatch(srcPatch);
1543 }
1544
1545
1546 // ***************************************************************************
1547 bool CPatchInfo::getNeighborTile (uint patchId, uint edge, sint position, uint &patchOut, sint &sOut, sint &tOut,
1548                                                                   const vector<CPatchInfo> &patchInfos) const
1549 {
1550         nlassert (edge<4);
1551
1552         // S or T ?
1553         uint length = (edge&1) ? OrderS : OrderT;
1554         nlassert ((uint)position<length);
1555
1556         // What kind of case ?
1557         switch (BindEdges[edge].NPatchs)
1558         {
1559         case 1:
1560         case 2:
1561         case 4:
1562                 {
1563                         // Get neighbor index and position in neighbor
1564                         uint neighborLength = (length / BindEdges[edge].NPatchs);
1565                         uint neighbor = position / neighborLength;
1566                         uint neighborPosition = neighborLength - (position % neighborLength) - 1;
1567                         uint neighborEdge = BindEdges[edge].Edge[neighbor];
1568
1569                         // Patch id
1570                         patchOut = BindEdges[edge].Next[neighbor];
1571
1572                         // Check neighbor
1573                         uint neighborRealLength = (neighborEdge&1) ? patchInfos[patchOut].OrderS : patchInfos[patchOut].OrderT;
1574                         if (neighborRealLength == neighborLength)
1575                         {
1576                                 // Get final coordinate
1577                                 switch (neighborEdge)
1578                                 {
1579                                 case 0:
1580                                         sOut = 0;
1581                                         tOut = neighborPosition;
1582                                         break;
1583                                 case 1:
1584                                         sOut = neighborPosition;
1585                                         tOut = patchInfos[patchOut].OrderT-1;
1586                                         break;
1587                                 case 2:
1588                                         sOut = patchInfos[patchOut].OrderS-1;
1589                                         tOut = patchInfos[patchOut].OrderT-neighborPosition-1;
1590                                         break;
1591                                 case 3:
1592                                         sOut = patchInfos[patchOut].OrderS-neighborPosition-1;
1593                                         tOut = 0;
1594                                         break;
1595                                 }
1596
1597                                 // Ok todo remove
1598                                 return true;
1599                         }
1600                 }
1601                 break;
1602
1603         case 5:
1604                 {
1605                         // Find in the neighbor where we are
1606                         patchOut = BindEdges[edge].Next[0];
1607                         uint neighborEdge = BindEdges[edge].Edge[0];
1608                         uint neighborEdgeCount = patchInfos[patchOut].BindEdges[neighborEdge].NPatchs;
1609
1610                         // Check neighbor
1611                         uint neighborRealLength = (neighborEdge&1) ? patchInfos[patchOut].OrderS : patchInfos[patchOut].OrderT;
1612
1613                         // Good length ?
1614                         if ((neighborRealLength / neighborEdgeCount) == length)
1615                         {
1616                                 // Find us in the neighbor
1617                                 uint neighborPosition;
1618                                 for (neighborPosition=0; neighborPosition<neighborEdgeCount; neighborPosition++)
1619                                 {
1620                                         // Found ?
1621                                         if (patchInfos[patchOut].BindEdges[neighborEdge].Next[neighborPosition] == patchId)
1622                                                 break;
1623                                 }
1624
1625                                 // Must be found
1626                                 nlassert (neighborPosition!=neighborEdgeCount);
1627                                 neighborPosition = (neighborPosition + 1) * (neighborRealLength / neighborEdgeCount) - position - 1;
1628
1629                                 // Get final coordinate
1630                                 switch (neighborEdge)
1631                                 {
1632                                 case 0:
1633                                         sOut = 0;
1634                                         tOut = neighborPosition;
1635                                         break;
1636                                 case 1:
1637                                         sOut = neighborPosition;
1638                                         tOut = patchInfos[patchOut].OrderT-1;
1639                                         break;
1640                                 case 2:
1641                                         sOut = patchInfos[patchOut].OrderS-1;
1642                                         tOut = patchInfos[patchOut].OrderT-neighborPosition-1;
1643                                         break;
1644                                 case 3:
1645                                         sOut = patchInfos[patchOut].OrderS-neighborPosition-1;
1646                                         tOut = 0;
1647                                         break;
1648                                 }
1649
1650                                 // Ok
1651                                 return true;
1652                         }
1653                 }
1654                 break;
1655         }
1656
1657         return false;
1658 }
1659
1660
1661 // ***************************************************************************
1662
1663 bool CPatchInfo::getTileSymmetryRotate (const CTileBank &bank, uint tile, bool &symmetry, uint &rotate)
1664 {
1665         // Need check the tile ?
1666         if ( (symmetry || (rotate != 0)) && (tile != 0xffffffff) )
1667         {
1668                 // Tile exist ?
1669                 if (tile < (uint)bank.getTileCount())
1670                 {
1671                         // Get xref
1672                         int tileSet;
1673                         int number;
1674                         CTileBank::TTileType type;
1675
1676                         // Get tile xref
1677                         bank.getTileXRef ((int)tile, tileSet, number, type);
1678
1679                         if ((tileSet < 0) || (tileSet >= bank.getTileSetCount()))
1680                         {
1681                                 nlwarning("tile %d has an unknown tileSet (%d)",tile, tileSet);
1682                                 return false;
1683                         }
1684
1685                         // Is it an oriented tile ?
1686                         if (bank.getTileSet (tileSet)->getOriented())
1687                         {
1688                                 // New rotation value
1689                                 rotate = 0;
1690                         }
1691
1692                         // Ok
1693                         return true;
1694                 }
1695
1696                 return false;
1697         }
1698         else
1699                 return true;
1700 }
1701
1702 // ***************************************************************************
1703
1704 bool CPatchInfo::transformTile (const CTileBank &bank, uint &tile, uint &tileRotation, bool symmetry, uint rotate, bool goofy)
1705 {
1706         // Tile exist ?
1707         if ( (rotate!=0) || symmetry )
1708         {
1709                 if (tile < (uint)bank.getTileCount())
1710                 {
1711                         // Get xref
1712                         int tileSet;
1713                         int number;
1714                         CTileBank::TTileType type;
1715
1716                         // Get tile xref
1717                         bank.getTileXRef ((int)tile, tileSet, number, type);
1718
1719                         // Transition ?
1720                         if (type == CTileBank::transition)
1721                         {
1722                                 // Rotation for transition
1723                                 uint transRotate = rotate;
1724
1725                                 // Number should be ok
1726                                 nlassert (number>=0);
1727                                 nlassert (number<CTileSet::count);
1728
1729                                 // Tlie set number
1730                                 const CTileSet *pTileSet = bank.getTileSet (tileSet);
1731
1732                                 // Get border desc
1733                                 CTileSet::TFlagBorder oriented[4] =
1734                                 {
1735                                         pTileSet->getOrientedBorder (CTileSet::left, CTileSet::getEdgeType ((CTileSet::TTransition)number, CTileSet::left)),
1736                                         pTileSet->getOrientedBorder (CTileSet::bottom, CTileSet::getEdgeType ((CTileSet::TTransition)number, CTileSet::bottom)),
1737                                         pTileSet->getOrientedBorder (CTileSet::right, CTileSet::getEdgeType ((CTileSet::TTransition)number, CTileSet::right)),
1738                                         pTileSet->getOrientedBorder (CTileSet::top, CTileSet::getEdgeType ((CTileSet::TTransition)number, CTileSet::top))
1739                                 };
1740
1741                                 // Symmetry ?
1742                                 if (symmetry)
1743                                 {
1744                                         if ( (tileRotation & 1) ^ goofy )
1745                                         {
1746                                                 CTileSet::TFlagBorder tmp = oriented[1];
1747                                                 oriented[1] = CTileSet::getInvertBorder (oriented[3]);
1748                                                 oriented[3] = CTileSet::getInvertBorder (tmp);
1749                                                 oriented[2] = CTileSet::getInvertBorder (oriented[2]);
1750                                                 oriented[0] = CTileSet::getInvertBorder (oriented[0]);
1751                                         }
1752                                         else
1753                                         {
1754                                                 CTileSet::TFlagBorder tmp = oriented[0];
1755                                                 oriented[0] = CTileSet::getInvertBorder (oriented[2]);
1756                                                 oriented[2] = CTileSet::getInvertBorder (tmp);
1757                                                 oriented[1] = CTileSet::getInvertBorder (oriented[1]);
1758                                                 oriented[3] = CTileSet::getInvertBorder (oriented[3]);
1759                                         }
1760                                 }
1761
1762                                 // Rotation
1763                                 CTileSet::TFlagBorder edges[4];
1764                                 edges[0] = pTileSet->getOrientedBorder (CTileSet::left, oriented[(0 + transRotate )&3]);
1765                                 edges[1] = pTileSet->getOrientedBorder (CTileSet::bottom, oriented[(1 + transRotate )&3]);
1766                                 edges[2] = pTileSet->getOrientedBorder (CTileSet::right, oriented[(2 + transRotate )&3]);
1767                                 edges[3] = pTileSet->getOrientedBorder (CTileSet::top, oriented[(3 + transRotate )&3]);
1768
1769                                 // Get the good tile number
1770                                 CTileSet::TTransition transition = pTileSet->getTransitionTile (edges[3], edges[1], edges[0], edges[2]);
1771                                 nlassert ((CTileSet::TTransition)transition != CTileSet::notfound);
1772                                 tile = (uint)(pTileSet->getTransition (transition)->getTile ());
1773                         }
1774
1775                         // Transform rotation: invert rotation
1776                         tileRotation += rotate;
1777
1778                         // If goofy, add +2
1779                         if (goofy && symmetry)
1780                                 tileRotation += 2;
1781
1782                         // Mask the rotation
1783                         tileRotation &= 3;
1784                 }
1785                 else
1786                         return false;
1787         }
1788
1789         // Ok
1790         return true;
1791 }
1792
1793 // ***************************************************************************
1794
1795 void CPatchInfo::transform256Case (const CTileBank &bank, uint8 &case256, uint tileRotation, bool symmetry, uint rotate, bool goofy)
1796 {
1797         // Tile exist ?
1798         if ( (rotate!=0) || symmetry )
1799         {
1800                 // Symmetry ?
1801                 if (symmetry)
1802                 {
1803                         // Take the symmetry
1804                         uint symArray[4] = {3, 2, 1, 0};
1805                         case256 = symArray[case256];
1806
1807                         if (goofy && ((tileRotation & 1) ==0))
1808                                 case256 += 2;
1809                         if ((!goofy) && (tileRotation & 1))
1810                                 case256 += 2;
1811                 }
1812
1813                 // Rotation ?
1814                 case256 -= rotate;
1815                 case256 &= 3;
1816         }
1817 }
1818
1819 // ***************************************************************************
1820
1821 bool CPatchInfo::transform (std::vector<CPatchInfo> &patchInfo, NL3D::CZoneSymmetrisation &zoneSymmetry, const NL3D::CTileBank &bank, bool symmetry, uint rotate, float snapCell, float weldThreshold, const NLMISC::CMatrix &toOriginalSpace)
1822 {
1823         uint patchCount = (uint)patchInfo.size ();
1824         uint i;
1825
1826         // --- Export tile info Symmetry of the bind info.
1827         // --- Parse each patch and each edge
1828
1829         // For each patches
1830         NL3D::CZoneSymmetrisation::CError error;
1831
1832         // Build the structure
1833         if (!zoneSymmetry.build (patchInfo, snapCell, weldThreshold, bank, error, toOriginalSpace))
1834         {
1835                 return false;
1836         }
1837
1838         // Symmetry ?
1839         if (symmetry)
1840         {
1841                 for(i=0 ; i<patchCount; i++)
1842                 {
1843                         // Ref on the current patch
1844                         CPatchInfo &pi = patchInfo[i];
1845
1846                         // --- Symmetry vertex indexes
1847
1848                         // Vertices
1849                         CVector tmp = pi.Patch.Vertices[0];
1850                         pi.Patch.Vertices[0] = pi.Patch.Vertices[3];
1851                         pi.Patch.Vertices[3] = tmp;
1852                         tmp = pi.Patch.Vertices[1];
1853                         pi.Patch.Vertices[1] = pi.Patch.Vertices[2];
1854                         pi.Patch.Vertices[2] = tmp;
1855
1856                         // Tangents
1857                         tmp = pi.Patch.Tangents[0];
1858                         pi.Patch.Tangents[0] = pi.Patch.Tangents[5];
1859                         pi.Patch.Tangents[5] = tmp;
1860                         tmp = pi.Patch.Tangents[1];
1861                         pi.Patch.Tangents[1] = pi.Patch.Tangents[4];
1862                         pi.Patch.Tangents[4] = tmp;
1863                         tmp = pi.Patch.Tangents[2];
1864                         pi.Patch.Tangents[2] = pi.Patch.Tangents[3];
1865                         pi.Patch.Tangents[3] = tmp;
1866                         tmp = pi.Patch.Tangents[6];
1867                         pi.Patch.Tangents[6] = pi.Patch.Tangents[7];
1868                         pi.Patch.Tangents[7] = tmp;
1869
1870                         // Interior
1871                         tmp = pi.Patch.Interiors[0];
1872                         pi.Patch.Interiors[0] = pi.Patch.Interiors[3];
1873                         pi.Patch.Interiors[3] = tmp;
1874                         tmp = pi.Patch.Interiors[1];
1875                         pi.Patch.Interiors[1] = pi.Patch.Interiors[2];
1876                         pi.Patch.Interiors[2] = tmp;
1877
1878                         // ** Symmetries tile colors
1879
1880                         uint u,v;
1881                         uint countU = pi.OrderS/2+1;
1882                         uint countV = pi.OrderT+1;
1883                         for (v=0; v<countV; v++)
1884                         for (u=0; u<countU; u++)
1885                         {
1886                                 // Store it in the tile info
1887                                 uint index0 = u+v*(pi.OrderS+1);
1888                                 uint index1 = (pi.OrderS-u)+v*(pi.OrderS+1);
1889
1890                                 // XChg
1891                                 uint16 tmp = pi.TileColors[index0].Color565;
1892                                 pi.TileColors[index0].Color565 = pi.TileColors[index1].Color565;
1893                                 pi.TileColors[index1].Color565 = tmp;
1894                         }
1895
1896                         // Smooth flags
1897                         uint flags = (uint)(pi.getSmoothFlag (0))<<2;
1898                         flags |= (uint)(pi.getSmoothFlag (2))<<0;
1899                         flags |= (uint)(pi.getSmoothFlag (1))<<1;
1900                         flags |= (uint)(pi.getSmoothFlag (3))<<3;
1901                         pi.Flags &= ~3;
1902                         pi.Flags |= flags;
1903                 }
1904
1905                 // --- Symmetry of the bind info.
1906                 // --- Parse each patch and each edge
1907                 // For each patches
1908                 for (i=0 ; i<patchCount; i++)
1909                 {
1910                         // Ref on the patch info
1911                         CPatchInfo &pi = patchInfo[i];
1912
1913                         // Xchg left and right
1914                         swap (pi.BindEdges[0], pi.BindEdges[2]);
1915                         swap (pi.BaseVertices[0], pi.BaseVertices[3]);
1916                         swap (pi.BaseVertices[1], pi.BaseVertices[2]);
1917
1918                         // Flip edges
1919                         for (uint edge=0; edge<4; edge++)
1920                         {
1921                                 // Ref on the patch info
1922                                 CPatchInfo::CBindInfo &bindEdge = pi.BindEdges[edge];
1923
1924                                 uint next;
1925                                 // Look if it is a bind ?
1926                                 if ( (bindEdge.NPatchs>1) && (bindEdge.NPatchs!=5) )
1927                                 {
1928                                         for (next=0; next<(uint)bindEdge.NPatchs/2; next++)
1929                                         {
1930                                                 swap (bindEdge.Next[bindEdge.NPatchs - next - 1], bindEdge.Next[next]);
1931                                                 swap (bindEdge.Edge[bindEdge.NPatchs - next - 1], bindEdge.Edge[next]);
1932                                         }
1933                                 }
1934
1935                                 // Look if we are binded on a reversed edge
1936                                 uint bindCount = (bindEdge.NPatchs==5) ? 1 : bindEdge.NPatchs;
1937                                 for (next=0; next<bindCount; next++)
1938                                 {
1939                                         // Left or right ?
1940                                         if ( (bindEdge.Edge[next] & 1) == 0)
1941                                         {
1942                                                 // Invert
1943                                                 bindEdge.Edge[next] += 2;
1944                                                 bindEdge.Edge[next] &= 3;
1945                                         }
1946                                 }
1947                         }
1948                 }
1949         }
1950
1951         // For each patches
1952         for (i=0 ; i<patchCount; i++)
1953         {
1954                 // Tile infos
1955                 CPatchInfo &pi = patchInfo[i];
1956
1957                 // Backup tiles
1958                 std::vector<CTileElement>       tiles = pi.Tiles;
1959
1960                 int u,v;
1961                 for (v=0; v<pi.OrderT; v++)
1962                 for (u=0; u<pi.OrderS; u++)
1963                 {
1964                         // U tile
1965                         int uSymmetry = symmetry ? (pi.OrderS-u-1) : u;
1966
1967                         // Destination tile
1968                         CTileElement &element = pi.Tiles[u+v*pi.OrderS];
1969
1970                         // Copy the orginal symmetrical element
1971                         element = tiles[uSymmetry+v*pi.OrderS];
1972
1973                         // For each layer
1974                         for (int l=0; l<3; l++)
1975                         {
1976                                 // Empty ?
1977                                 if (element.Tile[l] != 0xffff)
1978                                 {
1979                                         // Get the tile index
1980                                         uint tile = element.Tile[l];
1981                                         uint tileRotation = element.getTileOrient (l);
1982
1983                                         // Get rot and symmetry for this tile
1984                                         uint tileRotate = rotate;
1985                                         bool tileSymmetry = symmetry;
1986                                         bool goofy = symmetry && (zoneSymmetry.getTileState (i, uSymmetry+v*pi.OrderS, l) == CZoneSymmetrisation::Goofy);
1987
1988                                         // Transform the transfo
1989                                         if (getTileSymmetryRotate (bank, tile, tileSymmetry, tileRotate))
1990                                         {
1991                                                 // Transform the tile
1992                                                 if (!transformTile (bank, tile, tileRotation, tileSymmetry, (4-tileRotate)&3, goofy))
1993                                                 {
1994                                                         // Info
1995                                                         nlwarning ("Error getting symmetrical / rotated zone tile.");
1996                                                         return false;
1997                                                 }
1998                                         }
1999                                         else
2000                                         {
2001                                                 // Info
2002                                                 nlwarning ("Error getting symmetrical / rotated zone tile.");
2003                                                 return false;
2004                                         }
2005
2006                                         // Set the tile
2007                                         element.Tile[l] = tile;
2008                                         element.setTileOrient (l, (uint8)tileRotation);
2009                                 }
2010                         }
2011
2012                         // Empty ?
2013                         if (element.Tile[0]!=0xffff)
2014                         {
2015                                 // Get 256 info
2016                                 bool is256x256;
2017                                 uint8 uvOff;
2018                                 element.getTile256Info (is256x256, uvOff);
2019
2020                                 // 256 ?
2021                                 if (is256x256)
2022                                 {
2023                                         // Get rot and symmetry for this tile
2024                                         uint tileRotate = rotate;
2025                                         bool tileSymmetry = symmetry;
2026                                         uint tileRotation = tiles[uSymmetry+v*pi.OrderS].getTileOrient (0);
2027                                         bool goofy = symmetry && (zoneSymmetry.getTileState (i, uSymmetry+v*pi.OrderS, 0) == CZoneSymmetrisation::Goofy);
2028
2029                                         // Transform the transfo
2030                                         getTileSymmetryRotate (bank, element.Tile[0], tileSymmetry, tileRotate);
2031
2032                                         // Transform the case
2033                                         transform256Case (bank, uvOff, tileRotation, tileSymmetry, (4-tileRotate)&3, goofy);
2034
2035                                         element.setTile256Info (true, uvOff);
2036                                 }
2037                         }
2038                 }
2039         }
2040
2041         // Ok
2042         return true;
2043 }
2044
2045 // ***************************************************************************
2046
2047 } // NL3D