basegfx/source/polygon/b3dpolygon.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: b3dpolygon.cxx,v $
  10  * $Revision: 1.13 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_basegfx.hxx"
  33 #include <osl/diagnose.h>
  34 #include <basegfx/polygon/b3dpolygon.hxx>
  35 #include <basegfx/point/b3dpoint.hxx>
  36 #include <basegfx/matrix/b3dhommatrix.hxx>
  37 #include <rtl/instance.hxx>
  38 #include <basegfx/point/b2dpoint.hxx>
  39 #include <basegfx/color/bcolor.hxx>
  40 #include <basegfx/matrix/b2dhommatrix.hxx>
  41 #include <vector>
  42 #include <algorithm>
  43
  44 //////////////////////////////////////////////////////////////////////////////
  45
  46 class CoordinateData3D
  47 {
  48     basegfx::B3DPoint                                                           maPoint;
  49
  50 public:
  51     CoordinateData3D()
  52     :   maPoint()
  53     {
  54     }
  55
  56     explicit CoordinateData3D(const basegfx::B3DPoint& rData)
  57     :   maPoint(rData)
  58     {
  59     }
  60
  61     const basegfx::B3DPoint& getCoordinate() const
  62     {
  63         return maPoint;
  64     }
  65
  66     void setCoordinate(const basegfx::B3DPoint& rValue)
  67     {
  68         if(rValue != maPoint)
  69             maPoint = rValue;
  70     }
  71
  72     bool operator==(const CoordinateData3D& rData) const
  73     {
  74         return (maPoint == rData.getCoordinate());
  75     }
  76
  77     void transform(const basegfx::B3DHomMatrix& rMatrix)
  78     {
  79         maPoint *= rMatrix;
  80     }
  81 };
  82
  83 //////////////////////////////////////////////////////////////////////////////
  84
  85 class CoordinateDataArray3D
  86 {
  87     typedef ::std::vector< CoordinateData3D > CoordinateData3DVector;
  88
  89     CoordinateData3DVector                                                      maVector;
  90
  91 public:
  92     explicit CoordinateDataArray3D(sal_uInt32 nCount)
  93     :   maVector(nCount)
  94     {
  95     }
  96
  97     explicit CoordinateDataArray3D(const CoordinateDataArray3D& rOriginal)
  98     :   maVector(rOriginal.maVector)
  99     {
 100     }
 101
 102     CoordinateDataArray3D(const CoordinateDataArray3D& rOriginal, sal_uInt32 nIndex, sal_uInt32 nCount)
 103     :   maVector(rOriginal.maVector.begin() + nIndex, rOriginal.maVector.begin() + (nIndex + nCount))
 104     {
 105     }
 106
 107     ~CoordinateDataArray3D()
 108     {
 109     }
 110
 111     ::basegfx::B3DVector getNormal() const
 112     {
 113         ::basegfx::B3DVector aRetval;
 114         const sal_uInt32 nPointCount(maVector.size());
 115
 116         if(nPointCount > 2)
 117         {
 118             sal_uInt32 nISmallest(0);
 119             sal_uInt32 a(0);
 120             const basegfx::B3DPoint* pSmallest(&maVector[0].getCoordinate());
 121             const basegfx::B3DPoint* pNext(0);
 122             const basegfx::B3DPoint* pPrev(0);
 123
 124             // To guarantee a correctly oriented point, choose an outmost one
 125             // which then cannot be concave
 126             for(a = 1; a < nPointCount; a++)
 127             {
 128                 const basegfx::B3DPoint& rCandidate = maVector[a].getCoordinate();
 129
 130                 if((rCandidate.getX() < pSmallest->getX())
 131                     || (rCandidate.getX() == pSmallest->getX() && rCandidate.getY() < pSmallest->getY())
 132                     || (rCandidate.getX() == pSmallest->getX() && rCandidate.getY() == pSmallest->getY() && rCandidate.getZ() < pSmallest->getZ()))
 133                 {
 134                     nISmallest = a;
 135                     pSmallest = &rCandidate;
 136                 }
 137             }
 138
 139             // look for a next point different from minimal one
 140             for(a = (nISmallest + 1) % nPointCount; a != nISmallest; a = (a + 1) % nPointCount)
 141             {
 142                 const basegfx::B3DPoint& rCandidate = maVector[a].getCoordinate();
 143
 144                 if(!rCandidate.equal(*pSmallest))
 145                 {
 146                     pNext = &rCandidate;
 147                     break;
 148                 }
 149             }
 150
 151             // look for a previous point different from minimal one
 152             for(a = (nISmallest + nPointCount - 1) % nPointCount; a != nISmallest; a = (a + nPointCount - 1) % nPointCount)
 153             {
 154                 const basegfx::B3DPoint& rCandidate = maVector[a].getCoordinate();
 155
 156                 if(!rCandidate.equal(*pSmallest))
 157                 {
 158                     pPrev = &rCandidate;
 159                     break;
 160                 }
 161             }
 162
 163             // we always have a minimal point. If we also have a different next and previous,
 164             // we can calculate the normal
 165             if(pNext && pPrev)
 166             {
 167                 const basegfx::B3DVector aPrev(*pPrev - *pSmallest);
 168                 const basegfx::B3DVector aNext(*pNext - *pSmallest);
 169
 170                 aRetval = cross(aPrev, aNext);
 171                 aRetval.normalize();
 172             }
 173         }
 174
 175         return aRetval;
 176     }
 177
 178     sal_uInt32 count() const
 179     {
 180         return maVector.size();
 181     }
 182
 183     bool operator==(const CoordinateDataArray3D& rCandidate) const
 184     {
 185         return (maVector == rCandidate.maVector);
 186     }
 187
 188     const basegfx::B3DPoint& getCoordinate(sal_uInt32 nIndex) const
 189     {
 190         return maVector[nIndex].getCoordinate();
 191     }
 192
 193     void setCoordinate(sal_uInt32 nIndex, const basegfx::B3DPoint& rValue)
 194     {
 195         maVector[nIndex].setCoordinate(rValue);
 196     }
 197
 198     void insert(sal_uInt32 nIndex, const CoordinateData3D& rValue, sal_uInt32 nCount)
 199     {
 200         if(nCount)
 201         {
 202             // add nCount copies of rValue
 203             CoordinateData3DVector::iterator aIndex(maVector.begin());
 204             aIndex += nIndex;
 205             maVector.insert(aIndex, nCount, rValue);
 206         }
 207     }
 208
 209     void insert(sal_uInt32 nIndex, const CoordinateDataArray3D& rSource)
 210     {
 211         const sal_uInt32 nCount(rSource.maVector.size());
 212
 213         if(nCount)
 214         {
 215             // insert data
 216             CoordinateData3DVector::iterator aIndex(maVector.begin());
 217             aIndex += nIndex;
 218             CoordinateData3DVector::const_iterator aStart(rSource.maVector.begin());
 219             CoordinateData3DVector::const_iterator aEnd(rSource.maVector.end());
 220             maVector.insert(aIndex, aStart, aEnd);
 221         }
 222     }
 223
 224     void remove(sal_uInt32 nIndex, sal_uInt32 nCount)
 225     {
 226         if(nCount)
 227         {
 228             // remove point data
 229             CoordinateData3DVector::iterator aStart(maVector.begin());
 230             aStart += nIndex;
 231             const CoordinateData3DVector::iterator aEnd(aStart + nCount);
 232             maVector.erase(aStart, aEnd);
 233         }
 234     }
 235
 236     void flip()
 237     {
 238         if(maVector.size() > 1)
 239         {
 240             const sal_uInt32 nHalfSize(maVector.size() >> 1L);
 241             CoordinateData3DVector::iterator aStart(maVector.begin());
 242             CoordinateData3DVector::iterator aEnd(maVector.end() - 1L);
 243
 244             for(sal_uInt32 a(0); a < nHalfSize; a++)
 245             {
 246                 ::std::swap(*aStart, *aEnd);
 247                 aStart++;
 248                 aEnd--;
 249             }
 250         }
 251     }
 252
 253     void transform(const ::basegfx::B3DHomMatrix& rMatrix)
 254     {
 255         CoordinateData3DVector::iterator aStart(maVector.begin());
 256         CoordinateData3DVector::iterator aEnd(maVector.end());
 257
 258         for(; aStart != aEnd; aStart++)
 259         {
 260             aStart->transform(rMatrix);
 261         }
 262     }
 263 };
 264
 265 //////////////////////////////////////////////////////////////////////////////
 266
 267 class BColorArray
 268 {
 269     typedef ::std::vector< ::basegfx::BColor > BColorDataVector;
 270
 271     BColorDataVector                                                                    maVector;
 272     sal_uInt32                                                                                  mnUsedEntries;
 273
 274 public:
 275     explicit BColorArray(sal_uInt32 nCount)
 276     :   maVector(nCount),
 277         mnUsedEntries(0L)
 278     {
 279     }
 280
 281     explicit BColorArray(const BColorArray& rOriginal)
 282     :   maVector(rOriginal.maVector),
 283         mnUsedEntries(rOriginal.mnUsedEntries)
 284     {
 285     }
 286
 287     BColorArray(const BColorArray& rOriginal, sal_uInt32 nIndex, sal_uInt32 nCount)
 288     :   maVector(),
 289         mnUsedEntries(0L)
 290     {
 291         BColorDataVector::const_iterator aStart(rOriginal.maVector.begin());
 292         aStart += nIndex;
 293         BColorDataVector::const_iterator aEnd(aStart);
 294         aEnd += nCount;
 295         maVector.reserve(nCount);
 296
 297         for(; aStart != aEnd; aStart++)
 298         {
 299             if(!aStart->equalZero())
 300                 mnUsedEntries++;
 301
 302             maVector.push_back(*aStart);
 303         }
 304     }
 305
 306     ~BColorArray()
 307     {
 308     }
 309
 310     sal_uInt32 count() const
 311     {
 312         return maVector.size();
 313     }
 314
 315     bool operator==(const BColorArray& rCandidate) const
 316     {
 317         return (maVector == rCandidate.maVector);
 318     }
 319
 320     bool isUsed() const
 321     {
 322         return (0L != mnUsedEntries);
 323     }
 324
 325     const ::basegfx::BColor& getBColor(sal_uInt32 nIndex) const
 326     {
 327         return maVector[nIndex];
 328     }
 329
 330     void setBColor(sal_uInt32 nIndex, const ::basegfx::BColor& rValue)
 331     {
 332         bool bWasUsed(mnUsedEntries && !maVector[nIndex].equalZero());
 333         bool bIsUsed(!rValue.equalZero());
 334
 335         if(bWasUsed)
 336         {
 337             if(bIsUsed)
 338             {
 339                 maVector[nIndex] = rValue;
 340             }
 341             else
 342             {
 343                 maVector[nIndex] = ::basegfx::BColor::getEmptyBColor();
 344                 mnUsedEntries--;
 345             }
 346         }
 347         else
 348         {
 349             if(bIsUsed)
 350             {
 351                 maVector[nIndex] = rValue;
 352                 mnUsedEntries++;
 353             }
 354         }
 355     }
 356
 357     void insert(sal_uInt32 nIndex, const ::basegfx::BColor& rValue, sal_uInt32 nCount)
 358     {
 359         if(nCount)
 360         {
 361             // add nCount copies of rValue
 362             BColorDataVector::iterator aIndex(maVector.begin());
 363             aIndex += nIndex;
 364             maVector.insert(aIndex, nCount, rValue);
 365
 366             if(!rValue.equalZero())
 367                 mnUsedEntries += nCount;
 368         }
 369     }
 370
 371     void insert(sal_uInt32 nIndex, const BColorArray& rSource)
 372     {
 373         const sal_uInt32 nCount(rSource.maVector.size());
 374
 375         if(nCount)
 376         {
 377             // insert data
 378             BColorDataVector::iterator aIndex(maVector.begin());
 379             aIndex += nIndex;
 380             BColorDataVector::const_iterator aStart(rSource.maVector.begin());
 381             BColorDataVector::const_iterator aEnd(rSource.maVector.end());
 382             maVector.insert(aIndex, aStart, aEnd);
 383
 384             for(; aStart != aEnd; aStart++)
 385             {
 386                 if(!aStart->equalZero())
 387                     mnUsedEntries++;
 388             }
 389         }
 390     }
 391
 392     void remove(sal_uInt32 nIndex, sal_uInt32 nCount)
 393     {
 394         if(nCount)
 395         {
 396             const BColorDataVector::iterator aDeleteStart(maVector.begin() + nIndex);
 397             const BColorDataVector::iterator aDeleteEnd(aDeleteStart + nCount);
 398             BColorDataVector::const_iterator aStart(aDeleteStart);
 399
 400             for(; mnUsedEntries && aStart != aDeleteEnd; aStart++)
 401             {
 402                 if(!aStart->equalZero())
 403                     mnUsedEntries--;
 404             }
 405
 406             // remove point data
 407             maVector.erase(aDeleteStart, aDeleteEnd);
 408         }
 409     }
 410
 411     void flip()
 412     {
 413         if(maVector.size() > 1)
 414         {
 415             const sal_uInt32 nHalfSize(maVector.size() >> 1L);
 416             BColorDataVector::iterator aStart(maVector.begin());
 417             BColorDataVector::iterator aEnd(maVector.end() - 1L);
 418
 419             for(sal_uInt32 a(0); a < nHalfSize; a++)
 420             {
 421                 ::std::swap(*aStart, *aEnd);
 422                 aStart++;
 423                 aEnd--;
 424             }
 425         }
 426     }
 427 };
 428
 429 //////////////////////////////////////////////////////////////////////////////
 430
 431 class NormalsArray3D
 432 {
 433     typedef ::std::vector< ::basegfx::B3DVector > NormalsData3DVector;
 434
 435     NormalsData3DVector                                                                 maVector;
 436     sal_uInt32                                                                                  mnUsedEntries;
 437
 438 public:
 439     explicit NormalsArray3D(sal_uInt32 nCount)
 440     :   maVector(nCount),
 441         mnUsedEntries(0L)
 442     {
 443     }
 444
 445     explicit NormalsArray3D(const NormalsArray3D& rOriginal)
 446     :   maVector(rOriginal.maVector),
 447         mnUsedEntries(rOriginal.mnUsedEntries)
 448     {
 449     }
 450
 451     NormalsArray3D(const NormalsArray3D& rOriginal, sal_uInt32 nIndex, sal_uInt32 nCount)
 452     :   maVector(),
 453         mnUsedEntries(0L)
 454     {
 455         NormalsData3DVector::const_iterator aStart(rOriginal.maVector.begin());
 456         aStart += nIndex;
 457         NormalsData3DVector::const_iterator aEnd(aStart);
 458         aEnd += nCount;
 459         maVector.reserve(nCount);
 460
 461         for(; aStart != aEnd; aStart++)
 462         {
 463             if(!aStart->equalZero())
 464                 mnUsedEntries++;
 465
 466             maVector.push_back(*aStart);
 467         }
 468     }
 469
 470     ~NormalsArray3D()
 471     {
 472     }
 473
 474     sal_uInt32 count() const
 475     {
 476         return maVector.size();
 477     }
 478
 479     bool operator==(const NormalsArray3D& rCandidate) const
 480     {
 481         return (maVector == rCandidate.maVector);
 482     }
 483
 484     bool isUsed() const
 485     {
 486         return (0L != mnUsedEntries);
 487     }
 488
 489     const ::basegfx::B3DVector& getNormal(sal_uInt32 nIndex) const
 490     {
 491         return maVector[nIndex];
 492     }
 493
 494     void setNormal(sal_uInt32 nIndex, const ::basegfx::B3DVector& rValue)
 495     {
 496         bool bWasUsed(mnUsedEntries && !maVector[nIndex].equalZero());
 497         bool bIsUsed(!rValue.equalZero());
 498
 499         if(bWasUsed)
 500         {
 501             if(bIsUsed)
 502             {
 503                 maVector[nIndex] = rValue;
 504             }
 505             else
 506             {
 507                 maVector[nIndex] = ::basegfx::B3DVector::getEmptyVector();
 508                 mnUsedEntries--;
 509             }
 510         }
 511         else
 512         {
 513             if(bIsUsed)
 514             {
 515                 maVector[nIndex] = rValue;
 516                 mnUsedEntries++;
 517             }
 518         }
 519     }
 520
 521     void insert(sal_uInt32 nIndex, const ::basegfx::B3DVector& rValue, sal_uInt32 nCount)
 522     {
 523         if(nCount)
 524         {
 525             // add nCount copies of rValue
 526             NormalsData3DVector::iterator aIndex(maVector.begin());
 527             aIndex += nIndex;
 528             maVector.insert(aIndex, nCount, rValue);
 529
 530             if(!rValue.equalZero())
 531                 mnUsedEntries += nCount;
 532         }
 533     }
 534
 535     void insert(sal_uInt32 nIndex, const NormalsArray3D& rSource)
 536     {
 537         const sal_uInt32 nCount(rSource.maVector.size());
 538
 539         if(nCount)
 540         {
 541             // insert data
 542             NormalsData3DVector::iterator aIndex(maVector.begin());
 543             aIndex += nIndex;
 544             NormalsData3DVector::const_iterator aStart(rSource.maVector.begin());
 545             NormalsData3DVector::const_iterator aEnd(rSource.maVector.end());
 546             maVector.insert(aIndex, aStart, aEnd);
 547
 548             for(; aStart != aEnd; aStart++)
 549             {
 550                 if(!aStart->equalZero())
 551                     mnUsedEntries++;
 552             }
 553         }
 554     }
 555
 556     void remove(sal_uInt32 nIndex, sal_uInt32 nCount)
 557     {
 558         if(nCount)
 559         {
 560             const NormalsData3DVector::iterator aDeleteStart(maVector.begin() + nIndex);
 561             const NormalsData3DVector::iterator aDeleteEnd(aDeleteStart + nCount);
 562             NormalsData3DVector::const_iterator aStart(aDeleteStart);
 563
 564             for(; mnUsedEntries && aStart != aDeleteEnd; aStart++)
 565             {
 566                 if(!aStart->equalZero())
 567                     mnUsedEntries--;
 568             }
 569
 570             // remove point data
 571             maVector.erase(aDeleteStart, aDeleteEnd);
 572         }
 573     }
 574
 575     void flip()
 576     {
 577         if(maVector.size() > 1)
 578         {
 579             const sal_uInt32 nHalfSize(maVector.size() >> 1L);
 580             NormalsData3DVector::iterator aStart(maVector.begin());
 581             NormalsData3DVector::iterator aEnd(maVector.end() - 1L);
 582
 583             for(sal_uInt32 a(0); a < nHalfSize; a++)
 584             {
 585                 ::std::swap(*aStart, *aEnd);
 586                 aStart++;
 587                 aEnd--;
 588             }
 589         }
 590     }
 591
 592     void transform(const basegfx::B3DHomMatrix& rMatrix)
 593     {
 594         NormalsData3DVector::iterator aStart(maVector.begin());
 595         NormalsData3DVector::iterator aEnd(maVector.end());
 596
 597         for(; aStart != aEnd; aStart++)
 598         {
 599             (*aStart) *= rMatrix;
 600         }
 601     }
 602 };
 603
 604 //////////////////////////////////////////////////////////////////////////////
 605
 606 class TextureCoordinate2D
 607 {
 608     typedef ::std::vector< ::basegfx::B2DPoint > TextureData2DVector;
 609
 610     TextureData2DVector                                                                 maVector;
 611     sal_uInt32                                                                                  mnUsedEntries;
 612
 613 public:
 614     explicit TextureCoordinate2D(sal_uInt32 nCount)
 615     :   maVector(nCount),
 616         mnUsedEntries(0L)
 617     {
 618     }
 619
 620     explicit TextureCoordinate2D(const TextureCoordinate2D& rOriginal)
 621     :   maVector(rOriginal.maVector),
 622         mnUsedEntries(rOriginal.mnUsedEntries)
 623     {
 624     }
 625
 626     TextureCoordinate2D(const TextureCoordinate2D& rOriginal, sal_uInt32 nIndex, sal_uInt32 nCount)
 627     :   maVector(),
 628         mnUsedEntries(0L)
 629     {
 630         TextureData2DVector::const_iterator aStart(rOriginal.maVector.begin());
 631         aStart += nIndex;
 632         TextureData2DVector::const_iterator aEnd(aStart);
 633         aEnd += nCount;
 634         maVector.reserve(nCount);
 635
 636         for(; aStart != aEnd; aStart++)
 637         {
 638             if(!aStart->equalZero())
 639                 mnUsedEntries++;
 640
 641             maVector.push_back(*aStart);
 642         }
 643     }
 644
 645     ~TextureCoordinate2D()
 646     {
 647     }
 648
 649     sal_uInt32 count() const
 650     {
 651         return maVector.size();
 652     }
 653
 654     bool operator==(const TextureCoordinate2D& rCandidate) const
 655     {
 656         return (maVector == rCandidate.maVector);
 657     }
 658
 659     bool isUsed() const
 660     {
 661         return (0L != mnUsedEntries);
 662     }
 663
 664     const ::basegfx::B2DPoint& getTextureCoordinate(sal_uInt32 nIndex) const
 665     {
 666         return maVector[nIndex];
 667     }
 668
 669     void setTextureCoordinate(sal_uInt32 nIndex, const ::basegfx::B2DPoint& rValue)
 670     {
 671         bool bWasUsed(mnUsedEntries && !maVector[nIndex].equalZero());
 672         bool bIsUsed(!rValue.equalZero());
 673
 674         if(bWasUsed)
 675         {
 676             if(bIsUsed)
 677             {
 678                 maVector[nIndex] = rValue;
 679             }
 680             else
 681             {
 682                 maVector[nIndex] = ::basegfx::B2DPoint::getEmptyPoint();
 683                 mnUsedEntries--;
 684             }
 685         }
 686         else
 687         {
 688             if(bIsUsed)
 689             {
 690                 maVector[nIndex] = rValue;
 691                 mnUsedEntries++;
 692             }
 693         }
 694     }
 695
 696     void insert(sal_uInt32 nIndex, const ::basegfx::B2DPoint& rValue, sal_uInt32 nCount)
 697     {
 698         if(nCount)
 699         {
 700             // add nCount copies of rValue
 701             TextureData2DVector::iterator aIndex(maVector.begin());
 702             aIndex += nIndex;
 703             maVector.insert(aIndex, nCount, rValue);
 704
 705             if(!rValue.equalZero())
 706                 mnUsedEntries += nCount;
 707         }
 708     }
 709
 710     void insert(sal_uInt32 nIndex, const TextureCoordinate2D& rSource)
 711     {
 712         const sal_uInt32 nCount(rSource.maVector.size());
 713
 714         if(nCount)
 715         {
 716             // insert data
 717             TextureData2DVector::iterator aIndex(maVector.begin());
 718             aIndex += nIndex;
 719             TextureData2DVector::const_iterator aStart(rSource.maVector.begin());
 720             TextureData2DVector::const_iterator aEnd(rSource.maVector.end());
 721             maVector.insert(aIndex, aStart, aEnd);
 722
 723             for(; aStart != aEnd; aStart++)
 724             {
 725                 if(!aStart->equalZero())
 726                     mnUsedEntries++;
 727             }
 728         }
 729     }
 730
 731     void remove(sal_uInt32 nIndex, sal_uInt32 nCount)
 732     {
 733         if(nCount)
 734         {
 735             const TextureData2DVector::iterator aDeleteStart(maVector.begin() + nIndex);
 736             const TextureData2DVector::iterator aDeleteEnd(aDeleteStart + nCount);
 737             TextureData2DVector::const_iterator aStart(aDeleteStart);
 738
 739             for(; mnUsedEntries && aStart != aDeleteEnd; aStart++)
 740             {
 741                 if(!aStart->equalZero())
 742                     mnUsedEntries--;
 743             }
 744
 745             // remove point data
 746             maVector.erase(aDeleteStart, aDeleteEnd);
 747         }
 748     }
 749
 750     void flip()
 751     {
 752         if(maVector.size() > 1)
 753         {
 754             const sal_uInt32 nHalfSize(maVector.size() >> 1L);
 755             TextureData2DVector::iterator aStart(maVector.begin());
 756             TextureData2DVector::iterator aEnd(maVector.end() - 1L);
 757
 758             for(sal_uInt32 a(0); a < nHalfSize; a++)
 759             {
 760                 ::std::swap(*aStart, *aEnd);
 761                 aStart++;
 762                 aEnd--;
 763             }
 764         }
 765     }
 766
 767     void transform(const ::basegfx::B2DHomMatrix& rMatrix)
 768     {
 769         TextureData2DVector::iterator aStart(maVector.begin());
 770         TextureData2DVector::iterator aEnd(maVector.end());
 771
 772         for(; aStart != aEnd; aStart++)
 773         {
 774             (*aStart) *= rMatrix;
 775         }
 776     }
 777 };
 778
 779 //////////////////////////////////////////////////////////////////////////////
 780
 781 class ImplB3DPolygon
 782 {
 783     // The point vector. This vector exists always and defines the
 784     // count of members.
 785     CoordinateDataArray3D                                                       maPoints;
 786
 787     // The BColor vector. This vectors are created on demand
 788     // and may be zero.
 789     BColorArray*                                                                        mpBColors;
 790
 791     // The Normals vector. This vectors are created on demand
 792     // and may be zero.
 793     NormalsArray3D*                                                                     mpNormals;
 794
 795     // The TextureCoordinates vector. This vectors are created on demand
 796     // and may be zero.
 797     TextureCoordinate2D*                                                        mpTextureCoordiantes;
 798
 799     // The calculated plane normal. mbPlaneNormalValid says if it's valid.
 800     ::basegfx::B3DVector                                                        maPlaneNormal;
 801
 802     // bitfield
 803     // flag which decides if this polygon is opened or closed
 804     unsigned                                                                            mbIsClosed : 1;
 805
 806     // flag which says if maPlaneNormal is up-to-date
 807     unsigned                                                                            mbPlaneNormalValid : 1;
 808
 809 protected:
 810     void invalidatePlaneNormal()
 811     {
 812         if(mbPlaneNormalValid)
 813         {
 814             mbPlaneNormalValid = false;
 815         }
 816     }
 817
 818 public:
 819     // This constructor is only used from the static identity polygon, thus
 820     // the RefCount is set to 1 to never 'delete' this static incarnation.
 821     ImplB3DPolygon()
 822     :   maPoints(0L),
 823         mpBColors(0L),
 824         mpNormals(0L),
 825         mpTextureCoordiantes(0L),
 826         maPlaneNormal(::basegfx::B3DVector::getEmptyVector()),
 827         mbIsClosed(false),
 828         mbPlaneNormalValid(true)
 829     {
 830         // complete initialization with defaults
 831     }
 832
 833     ImplB3DPolygon(const ImplB3DPolygon& rToBeCopied)
 834     :   maPoints(rToBeCopied.maPoints),
 835         mpBColors(0L),
 836         mpNormals(0L),
 837         mpTextureCoordiantes(0L),
 838         maPlaneNormal(rToBeCopied.maPlaneNormal),
 839         mbIsClosed(rToBeCopied.mbIsClosed),
 840         mbPlaneNormalValid(rToBeCopied.mbPlaneNormalValid)
 841     {
 842         // complete initialization using copy
 843         if(rToBeCopied.mpBColors && rToBeCopied.mpBColors->isUsed())
 844         {
 845             mpBColors = new BColorArray(*rToBeCopied.mpBColors);
 846         }
 847
 848         if(rToBeCopied.mpNormals && rToBeCopied.mpNormals->isUsed())
 849         {
 850             mpNormals = new NormalsArray3D(*rToBeCopied.mpNormals);
 851         }
 852
 853         if(rToBeCopied.mpTextureCoordiantes && rToBeCopied.mpTextureCoordiantes->isUsed())
 854         {
 855             mpTextureCoordiantes = new TextureCoordinate2D(*rToBeCopied.mpTextureCoordiantes);
 856         }
 857     }
 858
 859     ImplB3DPolygon(const ImplB3DPolygon& rToBeCopied, sal_uInt32 nIndex, sal_uInt32 nCount)
 860     :   maPoints(rToBeCopied.maPoints, nIndex, nCount),
 861         mpBColors(0L),
 862         mpNormals(0L),
 863         mpTextureCoordiantes(0L),
 864         maPlaneNormal(::basegfx::B3DVector::getEmptyVector()),
 865         mbIsClosed(rToBeCopied.mbIsClosed),
 866         mbPlaneNormalValid(false)
 867     {
 868         // complete initialization using partly copy
 869         if(rToBeCopied.mpBColors && rToBeCopied.mpBColors->isUsed())
 870         {
 871             mpBColors = new BColorArray(*rToBeCopied.mpBColors, nIndex, nCount);
 872
 873             if(!mpBColors->isUsed())
 874             {
 875                 delete mpBColors;
 876                 mpBColors = 0L;
 877             }
 878         }
 879
 880         if(rToBeCopied.mpNormals && rToBeCopied.mpNormals->isUsed())
 881         {
 882             mpNormals = new NormalsArray3D(*rToBeCopied.mpNormals, nIndex, nCount);
 883
 884             if(!mpNormals->isUsed())
 885             {
 886                 delete mpNormals;
 887                 mpNormals = 0L;
 888             }
 889         }
 890
 891         if(rToBeCopied.mpTextureCoordiantes && rToBeCopied.mpTextureCoordiantes->isUsed())
 892         {
 893             mpTextureCoordiantes = new TextureCoordinate2D(*rToBeCopied.mpTextureCoordiantes, nIndex, nCount);
 894
 895             if(!mpTextureCoordiantes->isUsed())
 896             {
 897                 delete mpTextureCoordiantes;
 898                 mpTextureCoordiantes = 0L;
 899             }
 900         }
 901     }
 902
 903     ~ImplB3DPolygon()
 904     {
 905         if(mpBColors)
 906         {
 907             delete mpBColors;
 908             mpBColors = 0L;
 909         }
 910
 911         if(mpNormals)
 912         {
 913             delete mpNormals;
 914             mpNormals = 0L;
 915         }
 916
 917         if(mpTextureCoordiantes)
 918         {
 919             delete mpTextureCoordiantes;
 920             mpTextureCoordiantes = 0L;
 921         }
 922     }
 923
 924     sal_uInt32 count() const
 925     {
 926         return maPoints.count();
 927     }
 928
 929     bool isClosed() const
 930     {
 931         return mbIsClosed;
 932     }
 933
 934     void setClosed(bool bNew)
 935     {
 936         if(bNew != (bool)mbIsClosed)
 937         {
 938             mbIsClosed = bNew;
 939         }
 940     }
 941
 942     inline bool impBColorsAreEqual(const ImplB3DPolygon& rCandidate) const
 943     {
 944         bool bBColorsAreEqual(true);
 945
 946         if(mpBColors)
 947         {
 948             if(rCandidate.mpBColors)
 949             {
 950                 bBColorsAreEqual = (*mpBColors == *rCandidate.mpBColors);
 951             }
 952             else
 953             {
 954                 // candidate has no BColors, so it's assumed all unused.
 955                 bBColorsAreEqual = !mpBColors->isUsed();
 956             }
 957         }
 958         else
 959         {
 960             if(rCandidate.mpBColors)
 961             {
 962                 // we have no TextureCoordiantes, so it's assumed all unused.
 963                 bBColorsAreEqual = !rCandidate.mpBColors->isUsed();
 964             }
 965         }
 966
 967         return bBColorsAreEqual;
 968     }
 969
 970     inline bool impNormalsAreEqual(const ImplB3DPolygon& rCandidate) const
 971     {
 972         bool bNormalsAreEqual(true);
 973
 974         if(mpNormals)
 975         {
 976             if(rCandidate.mpNormals)
 977             {
 978                 bNormalsAreEqual = (*mpNormals == *rCandidate.mpNormals);
 979             }
 980             else
 981             {
 982                 // candidate has no normals, so it's assumed all unused.
 983                 bNormalsAreEqual = !mpNormals->isUsed();
 984             }
 985         }
 986         else
 987         {
 988             if(rCandidate.mpNormals)
 989             {
 990                 // we have no normals, so it's assumed all unused.
 991                 bNormalsAreEqual = !rCandidate.mpNormals->isUsed();
 992             }
 993         }
 994
 995         return bNormalsAreEqual;
 996     }
 997
 998     inline bool impTextureCoordinatesAreEqual(const ImplB3DPolygon& rCandidate) const
 999     {
1000         bool bTextureCoordinatesAreEqual(true);
1001
1002         if(mpTextureCoordiantes)
1003         {
1004             if(rCandidate.mpTextureCoordiantes)
1005             {
1006                 bTextureCoordinatesAreEqual = (*mpTextureCoordiantes == *rCandidate.mpTextureCoordiantes);
1007             }
1008             else
1009             {
1010                 // candidate has no TextureCoordinates, so it's assumed all unused.
1011                 bTextureCoordinatesAreEqual = !mpTextureCoordiantes->isUsed();
1012             }
1013         }
1014         else
1015         {
1016             if(rCandidate.mpTextureCoordiantes)
1017             {
1018                 // we have no TextureCoordiantes, so it's assumed all unused.
1019                 bTextureCoordinatesAreEqual = !rCandidate.mpTextureCoordiantes->isUsed();
1020             }
1021         }
1022
1023         return bTextureCoordinatesAreEqual;
1024     }
1025
1026     bool operator==(const ImplB3DPolygon& rCandidate) const
1027     {
1028         if(mbIsClosed == rCandidate.mbIsClosed)
1029         {
1030             if(maPoints == rCandidate.maPoints)
1031             {
1032                 if(impBColorsAreEqual(rCandidate))
1033                 {
1034                     if(impNormalsAreEqual(rCandidate))
1035                     {
1036                         if(impTextureCoordinatesAreEqual(rCandidate))
1037                         {
1038                             return true;
1039                         }
1040                     }
1041                 }
1042             }
1043         }
1044
1045         return false;
1046     }
1047
1048     const ::basegfx::B3DPoint& getPoint(sal_uInt32 nIndex) const
1049     {
1050         return maPoints.getCoordinate(nIndex);
1051     }
1052
1053     void setPoint(sal_uInt32 nIndex, const ::basegfx::B3DPoint& rValue)
1054     {
1055         maPoints.setCoordinate(nIndex, rValue);
1056         invalidatePlaneNormal();
1057     }
1058
1059     void insert(sal_uInt32 nIndex, const ::basegfx::B3DPoint& rPoint, sal_uInt32 nCount)
1060     {
1061         if(nCount)
1062         {
1063             CoordinateData3D aCoordinate(rPoint);
1064             maPoints.insert(nIndex, aCoordinate, nCount);
1065             invalidatePlaneNormal();
1066
1067             if(mpBColors)
1068             {
1069                 mpBColors->insert(nIndex, ::basegfx::BColor::getEmptyBColor(), nCount);
1070             }
1071
1072             if(mpNormals)
1073             {
1074                 mpNormals->insert(nIndex, ::basegfx::B3DVector::getEmptyVector(), nCount);
1075             }
1076
1077             if(mpTextureCoordiantes)
1078             {
1079                 mpTextureCoordiantes->insert(nIndex, ::basegfx::B2DPoint::getEmptyPoint(), nCount);
1080             }
1081         }
1082     }
1083
1084     const ::basegfx::BColor& getBColor(sal_uInt32 nIndex) const
1085     {
1086         if(mpBColors)
1087         {
1088             return mpBColors->getBColor(nIndex);
1089         }
1090         else
1091         {
1092             return ::basegfx::BColor::getEmptyBColor();
1093         }
1094     }
1095
1096     void setBColor(sal_uInt32 nIndex, const ::basegfx::BColor& rValue)
1097     {
1098         if(!mpBColors)
1099         {
1100             if(!rValue.equalZero())
1101             {
1102                 mpBColors = new BColorArray(maPoints.count());
1103                 mpBColors->setBColor(nIndex, rValue);
1104             }
1105         }
1106         else
1107         {
1108             mpBColors->setBColor(nIndex, rValue);
1109
1110             if(!mpBColors->isUsed())
1111             {
1112                 delete mpBColors;
1113                 mpBColors = 0L;
1114             }
1115         }
1116     }
1117
1118     bool areBColorsUsed() const
1119     {
1120         return (mpBColors && mpBColors->isUsed());
1121     }
1122
1123     void clearBColors()
1124     {
1125         if(mpBColors)
1126         {
1127             delete mpBColors;
1128             mpBColors = 0L;
1129         }
1130     }
1131
1132     const ::basegfx::B3DVector& getNormal() const
1133     {
1134         if(!mbPlaneNormalValid)
1135         {
1136             const_cast< ImplB3DPolygon* >(this)->maPlaneNormal = maPoints.getNormal();
1137             const_cast< ImplB3DPolygon* >(this)->mbPlaneNormalValid = true;
1138         }
1139
1140         return maPlaneNormal;
1141     }
1142
1143     const ::basegfx::B3DVector& getNormal(sal_uInt32 nIndex) const
1144     {
1145         if(mpNormals)
1146         {
1147             return mpNormals->getNormal(nIndex);
1148         }
1149         else
1150         {
1151             return ::basegfx::B3DVector::getEmptyVector();
1152         }
1153     }
1154
1155     void setNormal(sal_uInt32 nIndex, const ::basegfx::B3DVector& rValue)
1156     {
1157         if(!mpNormals)
1158         {
1159             if(!rValue.equalZero())
1160             {
1161                 mpNormals = new NormalsArray3D(maPoints.count());
1162                 mpNormals->setNormal(nIndex, rValue);
1163             }
1164         }
1165         else
1166         {
1167             mpNormals->setNormal(nIndex, rValue);
1168
1169             if(!mpNormals->isUsed())
1170             {
1171                 delete mpNormals;
1172                 mpNormals = 0L;
1173             }
1174         }
1175     }
1176
1177     void transformNormals(const ::basegfx::B3DHomMatrix& rMatrix)
1178     {
1179         if(mpNormals)
1180         {
1181             mpNormals->transform(rMatrix);
1182         }
1183     }
1184
1185     bool areNormalsUsed() const
1186     {
1187         return (mpNormals && mpNormals->isUsed());
1188     }
1189
1190     void clearNormals()
1191     {
1192         if(mpNormals)
1193         {
1194             delete mpNormals;
1195             mpNormals = 0L;
1196         }
1197     }
1198
1199     const ::basegfx::B2DPoint& getTextureCoordinate(sal_uInt32 nIndex) const
1200     {
1201         if(mpTextureCoordiantes)
1202         {
1203             return mpTextureCoordiantes->getTextureCoordinate(nIndex);
1204         }
1205         else
1206         {
1207             return ::basegfx::B2DPoint::getEmptyPoint();
1208         }
1209     }
1210
1211     void setTextureCoordinate(sal_uInt32 nIndex, const ::basegfx::B2DPoint& rValue)
1212     {
1213         if(!mpTextureCoordiantes)
1214         {
1215             if(!rValue.equalZero())
1216             {
1217                 mpTextureCoordiantes = new TextureCoordinate2D(maPoints.count());
1218                 mpTextureCoordiantes->setTextureCoordinate(nIndex, rValue);
1219             }
1220         }
1221         else
1222         {
1223             mpTextureCoordiantes->setTextureCoordinate(nIndex, rValue);
1224
1225             if(!mpTextureCoordiantes->isUsed())
1226             {
1227                 delete mpTextureCoordiantes;
1228                 mpTextureCoordiantes = 0L;
1229             }
1230         }
1231     }
1232
1233     bool areTextureCoordinatesUsed() const
1234     {
1235         return (mpTextureCoordiantes && mpTextureCoordiantes->isUsed());
1236     }
1237
1238     void clearTextureCoordinates()
1239     {
1240         if(mpTextureCoordiantes)
1241         {
1242             delete mpTextureCoordiantes;
1243             mpTextureCoordiantes = 0L;
1244         }
1245     }
1246
1247     void transformTextureCoordinates(const ::basegfx::B2DHomMatrix& rMatrix)
1248     {
1249         if(mpTextureCoordiantes)
1250         {
1251             mpTextureCoordiantes->transform(rMatrix);
1252         }
1253     }
1254
1255     void insert(sal_uInt32 nIndex, const ImplB3DPolygon& rSource)
1256     {
1257         const sal_uInt32 nCount(rSource.maPoints.count());
1258
1259         if(nCount)
1260         {
1261             maPoints.insert(nIndex, rSource.maPoints);
1262             invalidatePlaneNormal();
1263
1264             if(rSource.mpBColors && rSource.mpBColors->isUsed())
1265             {
1266                 if(!mpBColors)
1267                 {
1268                     mpBColors = new BColorArray(maPoints.count());
1269                 }
1270
1271                 mpBColors->insert(nIndex, *rSource.mpBColors);
1272             }
1273             else
1274             {
1275                 if(mpBColors)
1276                 {
1277                     mpBColors->insert(nIndex, ::basegfx::BColor::getEmptyBColor(), nCount);
1278                 }
1279             }
1280
1281             if(rSource.mpNormals && rSource.mpNormals->isUsed())
1282             {
1283                 if(!mpNormals)
1284                 {
1285                     mpNormals = new NormalsArray3D(maPoints.count());
1286                 }
1287
1288                 mpNormals->insert(nIndex, *rSource.mpNormals);
1289             }
1290             else
1291             {
1292                 if(mpNormals)
1293                 {
1294                     mpNormals->insert(nIndex, ::basegfx::B3DVector::getEmptyVector(), nCount);
1295                 }
1296             }
1297
1298             if(rSource.mpTextureCoordiantes && rSource.mpTextureCoordiantes->isUsed())
1299             {
1300                 if(!mpTextureCoordiantes)
1301                 {
1302                     mpTextureCoordiantes = new TextureCoordinate2D(maPoints.count());
1303                 }
1304
1305                 mpTextureCoordiantes->insert(nIndex, *rSource.mpTextureCoordiantes);
1306             }
1307             else
1308             {
1309                 if(mpTextureCoordiantes)
1310                 {
1311                     mpTextureCoordiantes->insert(nIndex, ::basegfx::B2DPoint::getEmptyPoint(), nCount);
1312                 }
1313             }
1314         }
1315     }
1316
1317     void remove(sal_uInt32 nIndex, sal_uInt32 nCount)
1318     {
1319         if(nCount)
1320         {
1321             maPoints.remove(nIndex, nCount);
1322             invalidatePlaneNormal();
1323
1324             if(mpBColors)
1325             {
1326                 mpBColors->remove(nIndex, nCount);
1327
1328                 if(!mpBColors->isUsed())
1329                 {
1330                     delete mpBColors;
1331                     mpBColors = 0L;
1332                 }
1333             }
1334
1335             if(mpNormals)
1336             {
1337                 mpNormals->remove(nIndex, nCount);
1338
1339                 if(!mpNormals->isUsed())
1340                 {
1341                     delete mpNormals;
1342                     mpNormals = 0L;
1343                 }
1344             }
1345
1346             if(mpTextureCoordiantes)
1347             {
1348                 mpTextureCoordiantes->remove(nIndex, nCount);
1349
1350                 if(!mpTextureCoordiantes->isUsed())
1351                 {
1352                     delete mpTextureCoordiantes;
1353                     mpTextureCoordiantes = 0L;
1354                 }
1355             }
1356         }
1357     }
1358
1359     void flip()
1360     {
1361         if(maPoints.count() > 1)
1362         {
1363             maPoints.flip();
1364
1365             if(mbPlaneNormalValid)
1366             {
1367                 // mirror plane normal
1368                 maPlaneNormal = -maPlaneNormal;
1369             }
1370
1371             if(mpBColors)
1372             {
1373                 mpBColors->flip();
1374             }
1375
1376             if(mpNormals)
1377             {
1378                 mpNormals->flip();
1379             }
1380
1381             if(mpTextureCoordiantes)
1382             {
1383                 mpTextureCoordiantes->flip();
1384             }
1385         }
1386     }
1387
1388     bool hasDoublePoints() const
1389     {
1390         if(mbIsClosed)
1391         {
1392             // check for same start and end point
1393             const sal_uInt32 nIndex(maPoints.count() - 1L);
1394
1395             if(maPoints.getCoordinate(0L) == maPoints.getCoordinate(nIndex))
1396             {
1397                 const bool bBColorEqual(!mpBColors || (mpBColors->getBColor(0L) == mpBColors->getBColor(nIndex)));
1398
1399                 if(bBColorEqual)
1400                 {
1401                     const bool bNormalsEqual(!mpNormals || (mpNormals->getNormal(0L) == mpNormals->getNormal(nIndex)));
1402
1403                     if(bNormalsEqual)
1404                     {
1405                         const bool bTextureCoordinatesEqual(!mpTextureCoordiantes || (mpTextureCoordiantes->getTextureCoordinate(0L) == mpTextureCoordiantes->getTextureCoordinate(nIndex)));
1406
1407                         if(bTextureCoordinatesEqual)
1408                         {
1409                             return true;
1410                         }
1411                     }
1412                 }
1413             }
1414         }
1415
1416         // test for range
1417         for(sal_uInt32 a(0L); a < maPoints.count() - 1L; a++)
1418         {
1419             if(maPoints.getCoordinate(a) == maPoints.getCoordinate(a + 1L))
1420             {
1421                 const bool bBColorEqual(!mpBColors || (mpBColors->getBColor(a) == mpBColors->getBColor(a + 1L)));
1422
1423                 if(bBColorEqual)
1424                 {
1425                     const bool bNormalsEqual(!mpNormals || (mpNormals->getNormal(a) == mpNormals->getNormal(a + 1L)));
1426
1427                     if(bNormalsEqual)
1428                     {
1429                         const bool bTextureCoordinatesEqual(!mpTextureCoordiantes || (mpTextureCoordiantes->getTextureCoordinate(a) == mpTextureCoordiantes->getTextureCoordinate(a + 1L)));
1430
1431                         if(bTextureCoordinatesEqual)
1432                         {
1433                             return true;
1434                         }
1435                     }
1436                 }
1437             }
1438         }
1439
1440         return false;
1441     }
1442
1443     void removeDoublePointsAtBeginEnd()
1444     {
1445         // Only remove DoublePoints at Begin and End when poly is closed
1446         if(mbIsClosed)
1447         {
1448             bool bRemove;
1449
1450             do
1451             {
1452                 bRemove = false;
1453
1454                 if(maPoints.count() > 1L)
1455                 {
1456                     const sal_uInt32 nIndex(maPoints.count() - 1L);
1457                     bRemove = (maPoints.getCoordinate(0L) == maPoints.getCoordinate(nIndex));
1458
1459                     if(bRemove && mpBColors && !(mpBColors->getBColor(0L) == mpBColors->getBColor(nIndex)))
1460                     {
1461                         bRemove = false;
1462                     }
1463
1464                     if(bRemove && mpNormals && !(mpNormals->getNormal(0L) == mpNormals->getNormal(nIndex)))
1465                     {
1466                         bRemove = false;
1467                     }
1468
1469                     if(bRemove && mpTextureCoordiantes && !(mpTextureCoordiantes->getTextureCoordinate(0L) == mpTextureCoordiantes->getTextureCoordinate(nIndex)))
1470                     {
1471                         bRemove = false;
1472                     }
1473                 }
1474
1475                 if(bRemove)
1476                 {
1477                     const sal_uInt32 nIndex(maPoints.count() - 1L);
1478                     remove(nIndex, 1L);
1479                 }
1480             } while(bRemove);
1481         }
1482     }
1483
1484     void removeDoublePointsWholeTrack()
1485     {
1486         sal_uInt32 nIndex(0L);
1487
1488         // test as long as there are at least two points and as long as the index
1489         // is smaller or equal second last point
1490         while((maPoints.count() > 1L) && (nIndex <= maPoints.count() - 2L))
1491         {
1492             const sal_uInt32 nNextIndex(nIndex + 1L);
1493             bool bRemove(maPoints.getCoordinate(nIndex) == maPoints.getCoordinate(nNextIndex));
1494
1495             if(bRemove && mpBColors && !(mpBColors->getBColor(nIndex) == mpBColors->getBColor(nNextIndex)))
1496             {
1497                 bRemove = false;
1498             }
1499
1500             if(bRemove && mpNormals && !(mpNormals->getNormal(nIndex) == mpNormals->getNormal(nNextIndex)))
1501             {
1502                 bRemove = false;
1503             }
1504
1505             if(bRemove && mpTextureCoordiantes && !(mpTextureCoordiantes->getTextureCoordinate(nIndex) == mpTextureCoordiantes->getTextureCoordinate(nNextIndex)))
1506             {
1507                 bRemove = false;
1508             }
1509
1510             if(bRemove)
1511             {
1512                 // if next is same as index and the control vectors are unused, delete index
1513                 remove(nIndex, 1L);
1514             }
1515             else
1516             {
1517                 // if different, step forward
1518                 nIndex++;
1519             }
1520         }
1521     }
1522
1523     void transform(const ::basegfx::B3DHomMatrix& rMatrix)
1524     {
1525         maPoints.transform(rMatrix);
1526
1527         // Here, it seems to be possible to transform a valid plane normal and to avoid
1528         // invalidation, but it's not true. If the transformation contains shears or e.g.
1529         // perspective projection, the orthogonality to the transformed plane will not
1530         // be preserved. It may be possible to test that at the matrix to not invalidate in
1531         // all cases or to extract a matrix which does not 'shear' the vector which is
1532         // a normal in this case. As long as this is not sure, i will just invalidate.
1533         invalidatePlaneNormal();
1534     }
1535 };
1536
1537 //////////////////////////////////////////////////////////////////////////////
1538
1539 namespace basegfx
1540 {
1541     namespace { struct DefaultPolygon : public rtl::Static< B3DPolygon::ImplType,
1542                                                             DefaultPolygon > {}; }
1543
1544     B3DPolygon::B3DPolygon() :
1545         mpPolygon(DefaultPolygon::get())
1546     {
1547     }
1548
1549     B3DPolygon::B3DPolygon(const B3DPolygon& rPolygon) :
1550         mpPolygon(rPolygon.mpPolygon)
1551     {
1552     }
1553
1554     B3DPolygon::B3DPolygon(const B3DPolygon& rPolygon, sal_uInt32 nIndex, sal_uInt32 nCount) :
1555         mpPolygon(ImplB3DPolygon(*rPolygon.mpPolygon, nIndex, nCount))
1556     {
1557         // TODO(P2): one extra temporary here (cow_wrapper copies
1558         // given ImplB3DPolygon into its internal impl_t wrapper type)
1559         OSL_ENSURE(nIndex + nCount > rPolygon.mpPolygon->count(), "B3DPolygon constructor outside range (!)");
1560     }
1561
1562     B3DPolygon::~B3DPolygon()
1563     {
1564     }
1565
1566     B3DPolygon& B3DPolygon::operator=(const B3DPolygon& rPolygon)
1567     {
1568         mpPolygon = rPolygon.mpPolygon;
1569         return *this;
1570     }
1571
1572     void B3DPolygon::makeUnique()
1573     {
1574         mpPolygon.make_unique();
1575     }
1576
1577     bool B3DPolygon::operator==(const B3DPolygon& rPolygon) const
1578     {
1579         if(mpPolygon.same_object(rPolygon.mpPolygon))
1580             return true;
1581
1582         return (*mpPolygon == *rPolygon.mpPolygon);
1583     }
1584
1585     bool B3DPolygon::operator!=(const B3DPolygon& rPolygon) const
1586     {
1587         return !(*this == rPolygon);
1588     }
1589
1590     sal_uInt32 B3DPolygon::count() const
1591     {
1592         return mpPolygon->count();
1593     }
1594
1595     basegfx::B3DPoint B3DPolygon::getB3DPoint(sal_uInt32 nIndex) const
1596     {
1597         OSL_ENSURE(nIndex < mpPolygon->count(), "B3DPolygon access outside range (!)");
1598
1599         return mpPolygon->getPoint(nIndex);
1600     }
1601
1602     void B3DPolygon::setB3DPoint(sal_uInt32 nIndex, const basegfx::B3DPoint& rValue)
1603     {
1604         OSL_ENSURE(nIndex < mpPolygon->count(), "B3DPolygon access outside range (!)");
1605
1606         if(getB3DPoint(nIndex) != rValue)
1607             mpPolygon->setPoint(nIndex, rValue);
1608     }
1609
1610     BColor B3DPolygon::getBColor(sal_uInt32 nIndex) const
1611     {
1612         OSL_ENSURE(nIndex < mpPolygon->count(), "B3DPolygon access outside range (!)");
1613
1614         return mpPolygon->getBColor(nIndex);
1615     }
1616
1617     void B3DPolygon::setBColor(sal_uInt32 nIndex, const BColor& rValue)
1618     {
1619         OSL_ENSURE(nIndex < mpPolygon->count(), "B3DPolygon access outside range (!)");
1620
1621         if(mpPolygon->getBColor(nIndex) != rValue)
1622             mpPolygon->setBColor(nIndex, rValue);
1623     }
1624
1625     bool B3DPolygon::areBColorsUsed() const
1626     {
1627         return mpPolygon->areBColorsUsed();
1628     }
1629
1630     void B3DPolygon::clearBColors()
1631     {
1632         if(mpPolygon->areBColorsUsed())
1633             mpPolygon->clearBColors();
1634     }
1635
1636     B3DVector B3DPolygon::getNormal() const
1637     {
1638         return mpPolygon->getNormal();
1639     }
1640
1641     B3DVector B3DPolygon::getNormal(sal_uInt32 nIndex) const
1642     {
1643         OSL_ENSURE(nIndex < mpPolygon->count(), "B3DPolygon access outside range (!)");
1644
1645         return mpPolygon->getNormal(nIndex);
1646     }
1647
1648     void B3DPolygon::setNormal(sal_uInt32 nIndex, const B3DVector& rValue)
1649     {
1650         OSL_ENSURE(nIndex < mpPolygon->count(), "B3DPolygon access outside range (!)");
1651
1652         if(mpPolygon->getNormal(nIndex) != rValue)
1653             mpPolygon->setNormal(nIndex, rValue);
1654     }
1655
1656     void B3DPolygon::transformNormals(const B3DHomMatrix& rMatrix)
1657     {
1658         if(mpPolygon->areNormalsUsed() && !rMatrix.isIdentity())
1659             mpPolygon->transformNormals(rMatrix);
1660     }
1661
1662     bool B3DPolygon::areNormalsUsed() const
1663     {
1664         return mpPolygon->areNormalsUsed();
1665     }
1666
1667     void B3DPolygon::clearNormals()
1668     {
1669         if(mpPolygon->areNormalsUsed())
1670             mpPolygon->clearNormals();
1671     }
1672
1673     B2DPoint B3DPolygon::getTextureCoordinate(sal_uInt32 nIndex) const
1674     {
1675         OSL_ENSURE(nIndex < mpPolygon->count(), "B3DPolygon access outside range (!)");
1676
1677         return mpPolygon->getTextureCoordinate(nIndex);
1678     }
1679
1680     void B3DPolygon::setTextureCoordinate(sal_uInt32 nIndex, const B2DPoint& rValue)
1681     {
1682         OSL_ENSURE(nIndex < mpPolygon->count(), "B3DPolygon access outside range (!)");
1683
1684         if(mpPolygon->getTextureCoordinate(nIndex) != rValue)
1685             mpPolygon->setTextureCoordinate(nIndex, rValue);
1686     }
1687
1688     void B3DPolygon::transformTextureCoordiantes(const B2DHomMatrix& rMatrix)
1689     {
1690         if(mpPolygon->areTextureCoordinatesUsed() && !rMatrix.isIdentity())
1691             mpPolygon->transformTextureCoordinates(rMatrix);
1692     }
1693
1694     bool B3DPolygon::areTextureCoordinatesUsed() const
1695     {
1696         return mpPolygon->areTextureCoordinatesUsed();
1697     }
1698
1699     void B3DPolygon::clearTextureCoordinates()
1700     {
1701         if(mpPolygon->areTextureCoordinatesUsed())
1702             mpPolygon->clearTextureCoordinates();
1703     }
1704
1705     void B3DPolygon::insert(sal_uInt32 nIndex, const ::basegfx::B3DPoint& rPoint, sal_uInt32 nCount)
1706     {
1707         OSL_ENSURE(nIndex <= mpPolygon->count(), "B3DPolygon Insert outside range (!)");
1708
1709         if(nCount)
1710             mpPolygon->insert(nIndex, rPoint, nCount);
1711     }
1712
1713     void B3DPolygon::append(const basegfx::B3DPoint& rPoint, sal_uInt32 nCount)
1714     {
1715         if(nCount)
1716             mpPolygon->insert(mpPolygon->count(), rPoint, nCount);
1717     }
1718
1719     void B3DPolygon::insert(sal_uInt32 nIndex, const B3DPolygon& rPoly, sal_uInt32 nIndex2, sal_uInt32 nCount)
1720     {
1721         OSL_ENSURE(nIndex <= mpPolygon->count(), "B3DPolygon Insert outside range (!)");
1722
1723         if(rPoly.count())
1724         {
1725             if(!nCount)
1726             {
1727                 nCount = rPoly.count();
1728             }
1729
1730             if(0L == nIndex2 && nCount == rPoly.count())
1731             {
1732                 mpPolygon->insert(nIndex, *rPoly.mpPolygon);
1733             }
1734             else
1735             {
1736                 OSL_ENSURE(nIndex2 + nCount <= rPoly.mpPolygon->count(), "B3DPolygon Insert outside range (!)");
1737                 ImplB3DPolygon aTempPoly(*rPoly.mpPolygon, nIndex2, nCount);
1738                 mpPolygon->insert(nIndex, aTempPoly);
1739             }
1740         }
1741     }
1742
1743     void B3DPolygon::append(const B3DPolygon& rPoly, sal_uInt32 nIndex, sal_uInt32 nCount)
1744     {
1745         if(rPoly.count())
1746         {
1747             if(!nCount)
1748             {
1749                 nCount = rPoly.count();
1750             }
1751
1752             if(0L == nIndex && nCount == rPoly.count())
1753             {
1754                 mpPolygon->insert(mpPolygon->count(), *rPoly.mpPolygon);
1755             }
1756             else
1757             {
1758                 OSL_ENSURE(nIndex + nCount <= rPoly.mpPolygon->count(), "B3DPolygon Append outside range (!)");
1759                 ImplB3DPolygon aTempPoly(*rPoly.mpPolygon, nIndex, nCount);
1760                 mpPolygon->insert(mpPolygon->count(), aTempPoly);
1761             }
1762         }
1763     }
1764
1765     void B3DPolygon::remove(sal_uInt32 nIndex, sal_uInt32 nCount)
1766     {
1767         OSL_ENSURE(nIndex + nCount <= mpPolygon->count(), "B3DPolygon Remove outside range (!)");
1768
1769         if(nCount)
1770             mpPolygon->remove(nIndex, nCount);
1771     }
1772
1773     void B3DPolygon::clear()
1774     {
1775         mpPolygon = DefaultPolygon::get();
1776     }
1777
1778     bool B3DPolygon::isClosed() const
1779     {
1780         return mpPolygon->isClosed();
1781     }
1782
1783     void B3DPolygon::setClosed(bool bNew)
1784     {
1785         if(isClosed() != bNew)
1786             mpPolygon->setClosed(bNew);
1787     }
1788
1789     void B3DPolygon::flip()
1790     {
1791         if(count() > 1)
1792             mpPolygon->flip();
1793     }
1794
1795     bool B3DPolygon::hasDoublePoints() const
1796     {
1797         return (mpPolygon->count() > 1L && mpPolygon->hasDoublePoints());
1798     }
1799
1800     void B3DPolygon::removeDoublePoints()
1801     {
1802         if(hasDoublePoints())
1803         {
1804             mpPolygon->removeDoublePointsAtBeginEnd();
1805             mpPolygon->removeDoublePointsWholeTrack();
1806         }
1807     }
1808
1809     void B3DPolygon::transform(const basegfx::B3DHomMatrix& rMatrix)
1810     {
1811         if(mpPolygon->count() && !rMatrix.isIdentity())
1812         {
1813             mpPolygon->transform(rMatrix);
1814         }
1815     }
1816 } // end of namespace basegfx
1817
1818 //////////////////////////////////////////////////////////////////////////////
1819 // eof